Simplified AMVR
diff --git a/av1/common/blockd.c b/av1/common/blockd.c
index 049aa98..291ef76 100644
--- a/av1/common/blockd.c
+++ b/av1/common/blockd.c
@@ -169,8 +169,8 @@
if (is_global_mv_block(mbmi, gm_type)) return SIMPLE_TRANSLATION;
}
-#if CONFIG_FLEX_MVRES
- if (mbmi->pb_mv_precision <= MV_PRECISION_ONE_PEL) return SIMPLE_TRANSLATION;
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 1
+ if (mbmi->pb_mv_precision < mbmi->max_mv_precision) return SIMPLE_TRANSLATION;
#endif
if (is_motion_variation_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y]) &&
is_inter_mode(mbmi->mode) && mbmi->ref_frame[1] != INTRA_FRAME &&
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 9322dbe..902eeaa 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -1854,6 +1854,9 @@
}
static INLINE int is_interintra_allowed(const MB_MODE_INFO *mbmi) {
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 1
+ if (mbmi->pb_mv_precision <= MV_PRECISION_FOUR_PEL) return 0;
+#endif
return is_interintra_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y]) &&
is_interintra_allowed_mode(mbmi->mode) &&
is_interintra_allowed_ref(mbmi->ref_frame);
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index e8377e3..4754af2 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -1610,12 +1610,8 @@
};
static const aom_cdf_prob
- default_pb_mv_most_probable_precision_cdf[NUM_MV_PREC_MPP_CONTEXT]
- [CDF_SIZE(2)] = {
- { AOM_CDF2(24320) },
- { AOM_CDF2(24320) },
- { AOM_CDF2(24320) },
- };
+ default_pb_mv_most_probable_precision_cdf[NUM_MV_PREC_MPP_CONTEXT][CDF_SIZE(
+ 2)] = { { AOM_CDF2(26227) }, { AOM_CDF2(22380) }, { AOM_CDF2(15446) } };
#if ADAPTIVE_PRECISION_SETS
#if MODE_BASED_PRECISION_ADAPTATION
static const aom_cdf_prob default_pb_mv_precision_cdf
@@ -1646,21 +1642,14 @@
}
};
#elif MAX_NUM_OF_SUPPORTED_PRECISIONS == 4
-static const aom_cdf_prob
- default_pb_mv_precision_cdf[MV_PREC_DOWN_CONTEXTS]
- [NUM_PB_FLEX_QUALIFIED_MAX_PREC]
- [CDF_SIZE(FLEX_MV_COSTS_SIZE)] = {
- {
- { AOM_CDF3(24000, 29000) },
- { AOM_CDF3(24000, 29000) },
- { AOM_CDF3(24000, 29000) },
- },
- {
- { AOM_CDF3(24000, 29000) },
- { AOM_CDF3(24000, 29000) },
- { AOM_CDF3(24000, 29000) },
- },
- };
+static const aom_cdf_prob default_pb_mv_precision_cdf
+ [MV_PREC_DOWN_CONTEXTS][NUM_PB_FLEX_QUALIFIED_MAX_PREC]
+ [CDF_SIZE(FLEX_MV_COSTS_SIZE)] = { { { AOM_CDF3(10923, 21845) },
+ { AOM_CDF3(25702, 31870) },
+ { AOM_CDF3(18150, 31007) } },
+ { { AOM_CDF3(10923, 21845) },
+ { AOM_CDF3(25055, 31858) },
+ { AOM_CDF3(21049, 31413) } } };
#elif MAX_NUM_OF_SUPPORTED_PRECISIONS == 5
static const aom_cdf_prob
default_pb_mv_precision_cdf[MV_PREC_DOWN_CONTEXTS]
diff --git a/av1/common/entropymv.c b/av1/common/entropymv.c
index 36a4b46..11de5e7 100644
--- a/av1/common/entropymv.c
+++ b/av1/common/entropymv.c
@@ -12,12 +12,107 @@
#include "av1/common/av1_common_int.h"
#include "av1/common/entropymv.h"
+#if CONFIG_FLEX_MVRES
+static const nmv_context default_nmv_context = {
+ { AOM_CDF4(1126, 6354, 9638) }, // joints_cdf
+#if CONFIG_ADAPTIVE_MVD
+ { AOM_CDF4(4, 18825, 32748) }, // amvd_joints_cdf
+#endif // CONFIG_ADAPTIVE_MVD
+ { {
+ // Vertical component
+ { { AOM_CDF9(21158, 25976, 29130, 31210, 32237, 32636, 32712, 32716) },
+ { AOM_CDF10(20546, 25501, 29187, 31196, 32175, 32597, 32708, 32712,
+ 32716) },
+ { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, 23831,
+ 26810, 29789) },
+ { AOM_CDF11(22643, 27104, 29724, 31229, 32115, 32523, 32692, 32700,
+ 32704, 32708) },
+ { AOM_CDF11(26781, 29925, 31300, 32056, 32465, 32650, 32704, 32708,
+ 32712, 32716) },
+ { AOM_CDF11(26807, 30081, 31455, 32131, 32503, 32658, 32704, 32708,
+ 32712, 32716) },
+ { AOM_CDF11(30184, 31733, 32301, 32550, 32685, 32708, 32712, 32716,
+ 32720, 32724) } }, // class_cdf // fp
+#if CONFIG_ADAPTIVE_MVD
+ { AOM_CDF11(29390, 31689, 32431, 32665, 32712, 32716, 32720, 32724,
+ 32728, 32732) }, // class_cdf // fp
+#endif // CONFIG_ADAPTIVE_MVD
+ { { { AOM_CDF2(23476) }, { AOM_CDF2(22382) }, { AOM_CDF2(10351) } },
+ { { AOM_CDF2(21865) },
+ { AOM_CDF2(16937) },
+ { AOM_CDF2(13425) } } }, // class0_fp_cdf
+ { { AOM_CDF2(16528) },
+ { AOM_CDF2(11848) },
+ { AOM_CDF2(7635) } }, // fp_cdf
+
+ // CONFIG_FLEX_MVRES
+ { AOM_CDF2(128 * 128) }, // sign_cdf
+ { AOM_CDF2(4654) }, // class0_hp_cdf
+ { AOM_CDF2(12899) }, // hp_cdf
+ { AOM_CDF2(26486) }, // class0_cdf
+ { { AOM_CDF2(20370) },
+ { AOM_CDF2(19352) },
+ { AOM_CDF2(20184) },
+ { AOM_CDF2(19290) },
+ { AOM_CDF2(20751) },
+ { AOM_CDF2(23123) },
+ { AOM_CDF2(25179) },
+ { AOM_CDF2(27939) },
+ { AOM_CDF2(31466) },
+ { AOM_CDF2(16384) } }, // bits_cdf
+ },
+ {
+ // Horizontal component
+ { { AOM_CDF9(19297, 23907, 27450, 30145, 31606, 32456, 32712,
+ 32716) }, // class_cdf
+ { AOM_CDF10(18861, 23816, 27819, 30238, 31643, 32355, 32697, 32704,
+ 32708) }, // class_cdf
+ { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, 23831,
+ 26810, 29789) },
+ { AOM_CDF11(20444, 25375, 28587, 30567, 31750, 32345, 32628, 32700,
+ 32704, 32708) },
+ { AOM_CDF11(25106, 29051, 30835, 31758, 32302, 32574, 32703, 32707,
+ 32711, 32715) },
+ { AOM_CDF11(24435, 28901, 30875, 31825, 32348, 32583, 32702, 32706,
+ 32710, 32714) },
+ { AOM_CDF11(29338, 31380, 32155, 32475, 32654, 32708, 32712, 32716,
+ 32720, 32724) } },
+#if CONFIG_ADAPTIVE_MVD
+ { AOM_CDF11(28341, 31295, 32320, 32640, 32712, 32716, 32720, 32724,
+ 32728, 32732) }, // class_cdf // fp
+#endif // CONFIG_ADAPTIVE_MVD
+
+ { { { AOM_CDF2(21083) }, { AOM_CDF2(21153) }, { AOM_CDF2(7888) } },
+ { { AOM_CDF2(22423) },
+ { AOM_CDF2(16285) },
+ { AOM_CDF2(14031) } } }, // class0_fp_cdf
+ { { AOM_CDF2(16600) },
+ { AOM_CDF2(12569) },
+ { AOM_CDF2(8367) } }, // fp_cdf
+
+ { AOM_CDF2(128 * 128) }, // sign_cdf
+ { AOM_CDF2(3238) }, // class0_hp_cdf
+ { AOM_CDF2(15376) }, // hp_cdf
+ { AOM_CDF2(24569) }, // class0_cdf
+ { { AOM_CDF2(20048) },
+ { AOM_CDF2(19425) },
+ { AOM_CDF2(19816) },
+ { AOM_CDF2(19138) },
+ { AOM_CDF2(20583) },
+ { AOM_CDF2(23446) },
+ { AOM_CDF2(23440) },
+ { AOM_CDF2(26025) },
+ { AOM_CDF2(29968) },
+ { AOM_CDF2(16384) } }, // bits_cdf
+ } },
+};
+#else
static const nmv_context default_nmv_context = {
{ AOM_CDF4(4096, 11264, 19328) }, // joints_cdf
#if CONFIG_ADAPTIVE_MVD
{ AOM_CDF4(1024, 19328, 32740) }, // amvd_joints_cdf
-#endif // CONFIG_ADAPTIVE_MVD
+#endif // CONFIG_ADAPTIVE_MVD
{ {
// Vertical component
#if CONFIG_FLEX_MVRES
@@ -41,7 +136,7 @@
#if CONFIG_ADAPTIVE_MVD
{ AOM_CDF11(24672, 27976, 29858, 31320, 32758, 32759, 32760, 32762,
32764, 32767) }, // class_cdf // fp
-#endif // CONFIG_ADAPTIVE_MVD
+#endif // CONFIG_ADAPTIVE_MVD
#if CONFIG_FLEX_MVRES
{ { { AOM_CDF2(24576) }, { AOM_CDF2(21845) }, { AOM_CDF2(8192) } },
{ { AOM_CDF2(21248) },
@@ -49,12 +144,12 @@
{ AOM_CDF2(8192) } } }, // class0_fp_cdf
{ { AOM_CDF2(17408) },
{ AOM_CDF2(15420) },
- { AOM_CDF2(8192) } }, // fp_cdf
+ { AOM_CDF2(8192) } }, // fp_cdf
#else
{ { AOM_CDF4(16384, 24576, 26624) },
{ AOM_CDF4(12288, 21248, 24128) } }, // class0_fp_cdf
{ AOM_CDF4(8192, 17408, 21248) }, // fp_cdf
-#endif // CONFIG_FLEX_MVRES
+#endif // CONFIG_FLEX_MVRES
{ AOM_CDF2(128 * 128) }, // sign_cdf
{ AOM_CDF2(160 * 128) }, // class0_hp_cdf
{ AOM_CDF2(128 * 128) }, // hp_cdf
@@ -97,7 +192,7 @@
#if CONFIG_ADAPTIVE_MVD
{ AOM_CDF11(24672, 27976, 29858, 31320, 32758, 32759, 32760, 32762,
32764, 32767) }, // class_cdf // fp
-#endif // CONFIG_ADAPTIVE_MVD
+#endif // CONFIG_ADAPTIVE_MVD
#if CONFIG_FLEX_MVRES
{ { { AOM_CDF2(24576) }, { AOM_CDF2(21845) }, { AOM_CDF2(8192) } },
{ { AOM_CDF2(21248) },
@@ -105,12 +200,12 @@
{ AOM_CDF2(8192) } } }, // class0_fp_cdf
{ { AOM_CDF2(17408) },
{ AOM_CDF2(15420) },
- { AOM_CDF2(8192) } }, // fp_cdf
+ { AOM_CDF2(8192) } }, // fp_cdf
#else
{ { AOM_CDF4(16384, 24576, 26624) },
{ AOM_CDF4(12288, 21248, 24128) } }, // class0_fp_cdf
{ AOM_CDF4(8192, 17408, 21248) }, // fp_cdf
-#endif // CONFIG_FLEX_MVRES
+#endif // CONFIG_FLEX_MVRES
{ AOM_CDF2(128 * 128) }, // sign_cdf
{ AOM_CDF2(160 * 128) }, // class0_hp_cdf
{ AOM_CDF2(128 * 128) }, // hp_cdf
@@ -127,6 +222,7 @@
{ AOM_CDF2(128 * 240) } }, // bits_cdf
} },
};
+#endif
void av1_init_mv_probs(AV1_COMMON *cm) {
// NB: this sets CDFs too
diff --git a/av1/common/enums.h b/av1/common/enums.h
index f0da133..02634dd 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -32,26 +32,12 @@
#if CONFIG_FLEX_MVRES
#define DEBUG_FLEX_MV 0
#define ADAPTIVE_PRECISION_SETS \
- 0 // Enable adaptive precision sets for each block
+ 1 // Enable adaptive precision sets for each block
#define FAST_FLEX_MV_ENCODER 1 // Enable fast encoder searching algorithms
-
-#if FAST_FLEX_MV_ENCODER
-#define REUSE_PREV_MV 2 // 1 for partial MV reuse, 2 for full MV reuse
-#define SKIP_NEW_MV_ET \
- 0 // Terminate early if similar MV was not better in earlier
-#define SKIP_REPEATED_FULL_NEW_MV \
- 0 // Skip repeated newMV of previous ref_mv_idx during motion search for
- // higher precisions
-#define ENABLE_SKIP_NEW_MV_FOR_HIGH_PRECISIONS \
- 0 // Skip RDO of the repeated newMV for higher precisions.
-#define MODEL_RDO_BASED_SEARCH 0 // Use model based RD for precision search
-
-#if REUSE_PREV_MV == 2
-#define FAST_MV_REFINEMENT \
- 0 // Fast refinement of MV for low precision. 1 means only less than int pel;
- // 2 means 1 + all precisions in the single ref mode; 3 means 1 + 2 + all
-#endif // REUSE_PREV_MV
-#endif // FAST_ALGORITHMS
+#define DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION \
+ 1 // 0 means do not disable, 1 means normatively disable, 2 means encoder
+ // does not search
+#define DISABLE_NEW_NEAR_MODES_FOR_FLEX_MV 0
#if ADAPTIVE_PRECISION_SETS
#define MODE_BASED_PRECISION_ADAPTATION \
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index 15c4a1f..9300fd4 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -2921,14 +2921,20 @@
MB_MODE_INFO *mbmi,
const BLOCK_SIZE bsize) {
(void)bsize;
+
+#if !ADAPTIVE_PRECISION_SETS
mbmi->most_probable_pb_mv_precision =
cm->features.most_probable_fr_mv_precision;
assert(mbmi->most_probable_pb_mv_precision <= mbmi->max_mv_precision);
-
-#if ADAPTIVE_PRECISION_SETS && DEBUG_FLEX_MV
- int mpp_found = 0;
+#else
+ (void)cm;
const PRECISION_SET *precision_def =
&av1_mv_precision_sets[mbmi->mb_precision_set];
+ mbmi->most_probable_pb_mv_precision =
+ precision_def->precision[precision_def->num_precisions - 1];
+
+#if DEBUG_FLEX_MV
+ int mpp_found = 0;
for (int precision_dx = precision_def->num_precisions - 1; precision_dx >= 0;
precision_dx--) {
MvSubpelPrecision pb_mv_precision = precision_def->precision[precision_dx];
@@ -2938,6 +2944,8 @@
}
}
CHECK_FLEX_MV(!mpp_found, "MPP is not found in the preceision set");
+ assert(mpp_found);
+#endif
#endif
}
@@ -3005,6 +3013,16 @@
#if CONFIG_ADAPTIVE_MVD
if (enable_adaptive_mvd_resolution(cm, mbmi)) return 0;
#endif
+
+#if DISABLE_NEW_NEAR_MODES_FOR_FLEX_MV
+ if (mbmi->mode == NEW_NEARMV || mbmi->mode == NEAR_NEWMV
+#if CONFIG_OPTFLOW_REFINEMENT
+ || mbmi->mode == NEAR_NEWMV_OPTFLOW || mbmi->mode == NEW_NEARMV_OPTFLOW
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ )
+ return 0;
+#endif
+
return mbmi->max_mv_precision >= MV_PRECISION_HALF_PEL &&
cm->features.use_pb_mv_precision &&
have_newmv_in_inter_mode(mbmi->mode);
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index a671ee2..c6077a7 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -622,8 +622,8 @@
(void)cm;
const MB_MODE_INFO *const mbmi = xd->mi[0];
-#if CONFIG_FLEX_MVRES
- if (mbmi->pb_mv_precision <= MV_PRECISION_ONE_PEL) return 0;
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 1
+ if (mbmi->pb_mv_precision < mbmi->max_mv_precision) return 0;
#endif
if (mbmi->skip_mode) return 0;
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index bd7aa6e..ebabda9 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -96,24 +96,6 @@
int refs[2];
} WinnerModeStats;
-#if CONFIG_FLEX_MVRES && MODEL_RDO_BASED_SEARCH
-typedef struct {
- //! The best mbmi mode.
- MB_MODE_INFO best_mbmi;
- //! The best model rd for this precision.
- int64_t model_rd;
- //! The best mode index of this precision.
- int rate_mv;
- //! The skip his precision for full RDO or not
- uint8_t skip_this_precision;
-
- //! The best mv value
- int_mv cur_mv[2];
- //! The return value of motion search
- int64_t newmv_ret_val;
-} PrecisionStats;
-#endif
-
/*! \brief Each source plane of the current macroblock
*
* This struct also stores the txfm buffers and quantizer settings.
@@ -916,6 +898,14 @@
int *amvd_nmv_cost[2];
#endif // CONFIG_ADAPTIVE_MVD
+#if CONFIG_BVCOST_UPDATE
+ /*! Costs for coding the zero components of dv cost. */
+ int *dv_joint_cost;
+
+ /*! Points to the middle of dvcost. */
+ int *dv_nmv_cost[2];
+#endif
+
#else
/*****************************************************************************
* \name Encoding Costs
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index bad02bd..add20fb 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c
@@ -1540,7 +1540,7 @@
#if CONFIG_BVCOST_UPDATE
if (cm->features.allow_intrabc) {
#if CONFIG_FLEX_MVRES
- fill_dv_costs(&cpi->dv_costs, cm->fc);
+ fill_dv_costs(&cpi->dv_costs, xd->tile_ctx, &x->mv_costs);
#else
av1_fill_dv_costs(xd->tile_ctx, &cpi->dv_costs);
#endif
diff --git a/av1/encoder/firstpass.c b/av1/encoder/firstpass.c
index c3e9229..5d287d3 100644
--- a/av1/encoder/firstpass.c
+++ b/av1/encoder/firstpass.c
@@ -239,13 +239,19 @@
}
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = cm->features.fr_mv_precision;
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
+#endif
#endif
FULLPEL_MOTION_SEARCH_PARAMS ms_params;
#if CONFIG_FLEX_MVRES
- av1_make_default_fullpel_ms_params(&ms_params, cpi, x, bsize, ref_mv,
- pb_mv_precision, first_pass_search_sites,
- fine_search_interval);
+ av1_make_default_fullpel_ms_params(
+ &ms_params, cpi, x, bsize, ref_mv, pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
+ first_pass_search_sites, fine_search_interval);
#else
av1_make_default_fullpel_ms_params(&ms_params, cpi, x, bsize, ref_mv,
first_pass_search_sites,
diff --git a/av1/encoder/interp_search.c b/av1/encoder/interp_search.c
index 012d20b..9fc5d36 100644
--- a/av1/encoder/interp_search.c
+++ b/av1/encoder/interp_search.c
@@ -366,6 +366,14 @@
if (*skip_hor == 0 && *skip_ver == 1) *skip_ver = 0;
}
}
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 2
+int skip_interpolation_filter_search_precision(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi,
+ BLOCK_SIZE bsize) {
+ return (is_pb_mv_precision_active(cm, mbmi, bsize) &&
+ (mbmi->pb_mv_precision < mbmi->max_mv_precision));
+}
+#endif
/*!\brief AV1 interpolation filter search
*
@@ -415,7 +423,12 @@
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
- const int need_search = av1_is_interp_needed(cm, xd);
+ const int need_search =
+ av1_is_interp_needed(cm, xd)
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 2
+ && !skip_interpolation_filter_search_precision(cm, mbmi, bsize)
+#endif
+ ;
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
const int ref_frame = COMPACT_INDEX0_NRS(xd->mi[0]->ref_frame[0]);
#else
diff --git a/av1/encoder/interp_search.h b/av1/encoder/interp_search.h
index 37dcaa0..3f9823f 100644
--- a/av1/encoder/interp_search.h
+++ b/av1/encoder/interp_search.h
@@ -170,6 +170,12 @@
int64_t *const rd, int *const switchable_rate, int *skip_build_pred,
HandleInterModeArgs *args, int64_t ref_best_rd);
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 2
+int skip_interpolation_filter_search_precision(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi,
+ BLOCK_SIZE bsize);
+#endif
+
/*!\endcond */
#ifdef __cplusplus
} // extern "C"
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index c6717f8..3f85597 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -42,6 +42,10 @@
#if CONFIG_FLEX_MVRES
,
MvSubpelPrecision pb_mv_precision
+#if CONFIG_BVCOST_UPDATE
+ ,
+ const int is_ibc_cost
+#endif
#endif
) {
mv_cost_params->ref_mv = ref_mv;
@@ -56,6 +60,10 @@
mv_cost_params->is_adaptive_mvd = is_adaptive_mvd;
#endif // CONFIG_ADAPTIVE_MVD
+#if CONFIG_BVCOST_UPDATE
+ mv_cost_params->is_ibc_cost = is_ibc_cost;
+#endif
+
#else
mv_cost_params->error_per_bit = mv_costs->errorperbit;
mv_cost_params->sad_per_bit = mv_costs->sadperbit;
@@ -111,12 +119,15 @@
const MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv,
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost,
+#endif
#endif
const search_site_config search_sites[NUM_DISTINCT_SEARCH_METHODS],
int fine_search_interval) {
const MV_SPEED_FEATURES *mv_sf = &cpi->sf.mv_sf;
-#if CONFIG_ADAPTIVE_MVD || CONFIG_TIP
+#if CONFIG_ADAPTIVE_MVD || CONFIG_TIP || CONFIG_FLEX_MVRES
const MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi = xd->mi[0];
#endif // CONFIG_ADAPTIVE_MVD || CONFIG_TIP
@@ -159,10 +170,11 @@
ms_params->fine_search_interval = fine_search_interval;
ms_params->is_intra_mode = 0;
-#if CONFIG_FLEX_MVRES && REUSE_PREV_MV == 2
- ms_params->fast_obmc_search = (pb_mv_precision == mbmi->max_mv_precision)
- ? mv_sf->obmc_full_pixel_search_level
- : 1;
+#if CONFIG_FLEX_MVRES
+ ms_params->fast_obmc_search =
+ (pb_mv_precision == mbmi->max_mv_precision)
+ ? mv_sf->obmc_full_pixel_search_level
+ : cpi->sf.flexmv_sf.low_prec_obmc_full_pixel_search_level;
#else
ms_params->fast_obmc_search = mv_sf->obmc_full_pixel_search_level;
#endif
@@ -189,7 +201,13 @@
is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
#if CONFIG_FLEX_MVRES
- ref_mv, pb_mv_precision);
+ ref_mv, pb_mv_precision
+#if CONFIG_BVCOST_UPDATE
+ ,
+ is_ibc_cost
+#endif
+
+ );
#else
ref_mv);
#endif
@@ -212,6 +230,10 @@
ms_params->allow_hp = cm->features.allow_high_precision_mv;
#endif
+#if CONFIG_BVCOST_UPDATE && CONFIG_FLEX_MVRES
+ const int is_ibc_cost = 0;
+#endif
+
#if CONFIG_ADAPTIVE_MVD || CONFIG_TIP
const MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi = xd->mi[0];
@@ -250,7 +272,13 @@
is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
#if CONFIG_FLEX_MVRES
- ref_mv, pb_mv_precision);
+ ref_mv, pb_mv_precision
+
+#if CONFIG_BVCOST_UPDATE
+ ,
+ is_ibc_cost
+#endif
+ );
#else
ref_mv);
#endif
@@ -405,20 +433,45 @@
#if CONFIG_ADAPTIVE_MVD
const int is_adaptive_mvd,
#endif
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost,
+#endif
const MvCosts *mv_costs, int weight, int round_bits) {
#if CONFIG_ADAPTIVE_MVD
- const int *mvjcost = is_adaptive_mvd ? mv_costs->amvd_nmv_joint_cost
- : mv_costs->nmv_joint_cost;
+ const int *mvjcost =
+ is_adaptive_mvd
+ ? mv_costs->amvd_nmv_joint_cost
+#if CONFIG_BVCOST_UPDATE
+ : (is_ibc_cost ? mv_costs->dv_joint_cost : mv_costs->nmv_joint_cost);
+#else
+ : mv_costs->nmv_joint_cost;
+#endif
const int *const *mvcost =
is_adaptive_mvd
? CONVERT_TO_CONST_MVCOST(mv_costs->amvd_nmv_cost)
+#if CONFIG_BVCOST_UPDATE
+ : (is_ibc_cost ? CONVERT_TO_CONST_MVCOST(mv_costs->dv_nmv_cost)
+ : CONVERT_TO_CONST_MVCOST(
+ mv_costs->nmv_costs[pb_mv_precision]));
+#else
: CONVERT_TO_CONST_MVCOST(mv_costs->nmv_costs[pb_mv_precision]);
+#endif
+
+#else
+#if CONFIG_BVCOST_UPDATE
+ const int *mvjcost =
+ (is_ibc_cost ? mv_costs->dv_joint_cost : mv_costs->nmv_joint_cost);
+ const int *const *mvcost =
+ (is_ibc_cost
+ ? CONVERT_TO_CONST_MVCOST(mv_costs->dv_nmv_cost)
+ : CONVERT_TO_CONST_MVCOST(mv_costs->nmv_costs[pb_mv_precision]));
#else
const int *mvjcost = mv_costs->nmv_joint_cost;
const int *const *mvcost =
CONVERT_TO_CONST_MVCOST(mv_costs->nmv_costs[pb_mv_precision]);
#endif
+#endif
MV low_prec_ref_mv = ref_mv;
lower_mv_precision(&low_prec_ref_mv, pb_mv_precision);
@@ -455,10 +508,18 @@
const int is_adaptive_mvd
#endif
) {
+#if CONFIG_BVCOST_UPDATE
+ // For ibc block this function should not be called
+ const int is_ibc_cost = 0;
+#endif
+
return get_mv_cost_with_precision(*mv, *ref_mv, pb_mv_precision,
#if CONFIG_ADAPTIVE_MVD
is_adaptive_mvd,
#endif
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
mv_costs, weight, 7);
}
@@ -499,6 +560,9 @@
#if CONFIG_ADAPTIVE_MVD
mv_cost_params->is_adaptive_mvd,
#endif
+#if CONFIG_BVCOST_UPDATE
+ mv_cost_params->is_ibc_cost,
+#endif
mv_costs, mv_costs->errorperbit,
RDDIV_BITS + AV1_PROB_COST_SHIFT - RD_EPB_SHIFT +
PIXEL_TRANSFORM_ERROR_SCALE);
@@ -551,9 +615,45 @@
const MV abs_diff = { abs(diff.row), abs(diff.col) };
const MvCosts *mv_costs = mv_cost_params->mv_costs;
+
+#if CONFIG_BVCOST_UPDATE
+ const int *mvjcost =
+ mv_cost_params->is_ibc_cost
+ ? mv_costs->dv_joint_cost
+#if CONFIG_ADAPTIVE_MVD
+ : (mv_cost_params->is_adaptive_mvd ? mv_costs->amvd_nmv_joint_cost
+ : mv_costs->nmv_joint_cost);
+#else
+ : mv_costs->nmv_joint_cost;
+#endif
+
+ const int *const *mvcost =
+ mv_cost_params->is_ibc_cost
+ ? CONVERT_TO_CONST_MVCOST(mv_costs->dv_nmv_cost)
+#if CONFIG_ADAPTIVE_MVD
+ : (mv_cost_params->is_adaptive_mvd
+ ? CONVERT_TO_CONST_MVCOST(mv_costs->amvd_nmv_cost)
+ : CONVERT_TO_CONST_MVCOST(
+ mv_costs->nmv_costs[pb_mv_precision]));
+#else
+ : CONVERT_TO_CONST_MVCOST(mv_costs->nmv_costs[pb_mv_precision]);
+#endif
+#else
+#if CONFIG_ADAPTIVE_MVD
+ const int *mvjcost = mv_cost_params->is_adaptive_mvd
+ ? mv_costs->amvd_nmv_joint_cost
+ : mv_costs->nmv_joint_cost;
+ const int *const *mvcost =
+ mv_cost_params->is_adaptive_mvd
+ ? CONVERT_TO_CONST_MVCOST(mv_costs->amvd_nmv_cost)
+ : CONVERT_TO_CONST_MVCOST(mv_costs->nmv_costs[pb_mv_precision]);
+#else
const int *mvjcost = mv_costs->nmv_joint_cost;
const int *const *mvcost =
CONVERT_TO_CONST_MVCOST(mv_costs->nmv_costs[pb_mv_precision]);
+#endif
+#endif
+
const int sad_per_bit = mv_costs->sadperbit;
const MV_COST_TYPE mv_cost_type = mv_cost_params->mv_cost_type;
@@ -2273,12 +2373,7 @@
// This function is called when we do joint motion search in comp_inter_inter
// mode, or when searching for one component of an ext-inter compound mode.
int av1_refining_search_8p_c(const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
- const FULLPEL_MV start_mv, FULLPEL_MV *best_mv
-#if CONFIG_FLEX_MVRES && FAST_MV_REFINEMENT > 1
- ,
- const int fast_mv_refinement
-#endif
-) {
+ const FULLPEL_MV start_mv, FULLPEL_MV *best_mv) {
static const search_neighbors neighbors[8] = {
{ { -1, 0 }, -1 * SEARCH_GRID_STRIDE_8P + 0 },
{ { 0, -1 }, 0 * SEARCH_GRID_STRIDE_8P - 1 },
@@ -2317,10 +2412,6 @@
best_sad += mvsad_err_cost_(best_mv, mv_cost_params);
#endif
-#if CONFIG_FLEX_MVRES && FAST_MV_REFINEMENT > 1
- if (fast_mv_refinement) return best_sad;
-#endif
-
do_refine_search_grid[grid_coord] = 1;
for (int i = 0; i < SEARCH_RANGE_8P; ++i) {
@@ -2377,7 +2468,7 @@
// compound mode.
int av1_refining_search_8p_c_low_precision(
const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV start_mv,
- FULLPEL_MV *best_mv) {
+ FULLPEL_MV *best_mv, int fast_mv_refinement) {
assert(ms_params->mv_cost_params.pb_mv_precision < MV_PRECISION_ONE_PEL);
const int search_range =
1 << (MV_PRECISION_ONE_PEL - ms_params->mv_cost_params.pb_mv_precision);
@@ -2398,11 +2489,9 @@
};
int grid_center = search_range * search_grid_stride + search_range;
-#if FAST_MV_REFINEMENT
- const int num_of_search_steps = 1;
-#else
- const int num_of_search_steps = 3;
-#endif
+
+ const int num_of_search_steps = fast_mv_refinement ? 1 : 3;
+
assert(ms_params->mv_cost_params.pb_mv_precision < MV_PRECISION_ONE_PEL);
const MV_COST_PARAMS *mv_cost_params = &ms_params->mv_cost_params;
const FullMvLimits *mv_limits = &ms_params->mv_limits;
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index 1c0965f..88bb86d 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h
@@ -93,7 +93,9 @@
#if CONFIG_ADAPTIVE_MVD
int is_adaptive_mvd;
#endif // CONFIG_ADAPTIVE_MVD
-
+#if CONFIG_BVCOST_UPDATE
+ int is_ibc_cost;
+#endif
#endif
} MV_COST_PARAMS;
@@ -244,6 +246,9 @@
const MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv,
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost,
+#endif
#endif
const search_site_config search_sites[NUM_DISTINCT_SEARCH_METHODS],
int fine_search_interval);
@@ -339,16 +344,11 @@
const MV *ref_mv);
int av1_refining_search_8p_c(const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
- const FULLPEL_MV start_mv, FULLPEL_MV *best_mv
-#if CONFIG_FLEX_MVRES && FAST_MV_REFINEMENT > 1
- ,
- const int fast_mv_refinement
-#endif
-);
+ const FULLPEL_MV start_mv, FULLPEL_MV *best_mv);
#if CONFIG_FLEX_MVRES
int av1_refining_search_8p_c_low_precision(
const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV start_mv,
- FULLPEL_MV *best_mv);
+ FULLPEL_MV *best_mv, int fast_mv_refinement);
#endif
int av1_full_pixel_search(const FULLPEL_MV start_mv,
diff --git a/av1/encoder/motion_search_facade.c b/av1/encoder/motion_search_facade.c
index ee1ab41..ad8425f 100644
--- a/av1/encoder/motion_search_facade.c
+++ b/av1/encoder/motion_search_facade.c
@@ -229,13 +229,19 @@
mv_search_params->search_site_cfg[SS_CFG_SRC];
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
+#endif
#endif
FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
#if CONFIG_FLEX_MVRES
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
- pb_mv_precision, src_search_sites,
- fine_search_interval);
+ pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
+ src_search_sites, fine_search_interval);
#else
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
src_search_sites, fine_search_interval);
@@ -441,16 +447,13 @@
#endif
}
-#if CONFIG_FLEX_MVRES && REUSE_PREV_MV
+#if CONFIG_FLEX_MVRES
void av1_single_motion_search_high_precision(const AV1_COMP *const cpi,
MACROBLOCK *x, BLOCK_SIZE bsize,
int ref_idx, int *rate_mv,
inter_mode_info *mode_info,
const int_mv *start_mv,
int_mv *best_mv) {
-#if !SKIP_REPEATED_FULL_NEW_MV
- (void)mode_info;
-#endif
MACROBLOCKD *xd = &x->e_mbd;
const AV1_COMMON *cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
@@ -491,24 +494,25 @@
lower_mv_precision(&ref_mv_low_prec, mbmi->pb_mv_precision);
const MV ref_mv = ref_mv_low_prec;
- av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
- pb_mv_precision, NULL, 0);
-#if CONFIG_FLEX_MVRES && FAST_MV_REFINEMENT > 1
- const int fast_mv_refinement = (pb_mv_precision != mbmi->max_mv_precision);
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
#endif
+ av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
+ pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
+
+ NULL, 0);
+
if (pb_mv_precision < MV_PRECISION_ONE_PEL)
bestsme = av1_refining_search_8p_c_low_precision(
- &full_ms_params, start_fullmv, &curr_best_mv.as_fullmv);
+ &full_ms_params, start_fullmv, &curr_best_mv.as_fullmv,
+ cpi->sf.flexmv_sf.fast_mv_refinement);
else
bestsme = av1_refining_search_8p_c(&full_ms_params, start_fullmv,
- &curr_best_mv.as_fullmv
-#if CONFIG_FLEX_MVRES && FAST_MV_REFINEMENT > 1
- ,
- fast_mv_refinement
-#endif
-
- );
+ &curr_best_mv.as_fullmv);
if (scaled_ref_frame) {
// Swap back the original buffers for subpel motion search.
@@ -524,28 +528,26 @@
" Error in MV precision value after integer search 1");
#endif
-#if SKIP_REPEATED_FULL_NEW_MV
-
// Terminate search with the current ref_idx if we have already encountered
// another ref_mv in the drl such that:
// 1. The other drl has the same fullpel_mv during the SIMPLE_TRANSLATION
// search process as the current fullpel_mv.
// 2. The rate needed to encode the current fullpel_mv is larger than that
// for the other ref_mv.
-#if 1
- if (mbmi->pb_mv_precision != mbmi->max_mv_precision &&
+ if (cpi->sf.flexmv_sf.skip_repeated_newmv_low_prec &&
+ mbmi->pb_mv_precision != mbmi->max_mv_precision &&
mbmi->motion_mode == SIMPLE_TRANSLATION &&
curr_best_mv.as_int != INVALID_MV) {
-#else
- if (cpi->sf.inter_sf.skip_repeated_full_newmv &&
- mbmi->motion_mode == SIMPLE_TRANSLATION &&
- curr_best_mv.as_int != INVALID_MV) {
-#endif
int_mv this_mv;
this_mv.as_mv = get_mv_from_fullmv(&curr_best_mv.as_fullmv);
const int ref_mv_idx = mbmi->ref_mv_idx;
const int this_mv_rate = av1_mv_bit_cost(
- &this_mv.as_mv, &ref_mv, pb_mv_precision, mv_costs, MV_COST_WEIGHT, 0);
+ &this_mv.as_mv, &ref_mv, pb_mv_precision, mv_costs, MV_COST_WEIGHT
+#if CONFIG_ADAPTIVE_MVD
+ ,
+ 0
+#endif
+ );
mode_info[ref_mv_idx].full_search_mv.as_int = this_mv.as_int;
mode_info[ref_mv_idx].full_mv_rate = this_mv_rate;
@@ -571,7 +573,6 @@
}
}
}
-#endif
#if DEBUG_FLEX_MV
CHECK_FLEX_MV(
@@ -726,12 +727,19 @@
// Do full-pixel compound motion search on the current reference frame.
if (id) xd->plane[plane].pre[0] = ref_yv12[id];
+#if CONFIG_FLEX_MVRES && CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
+#endif
+
// Make motion search params
FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize,
&ref_mv[id].as_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
#endif
NULL,
/*fine_search_interval=*/0);
@@ -744,25 +752,14 @@
// Small-range full-pixel motion search.
#if CONFIG_FLEX_MVRES
-#if FAST_MV_REFINEMENT > 1
-#if FAST_MV_REFINEMENT > 2
- const int fast_mv_refinement = (pb_mv_precision != mbmi->max_mv_precision);
-#else
- const int fast_mv_refinement = 0;
-#endif
-#endif
if (pb_mv_precision < MV_PRECISION_ONE_PEL)
bestsme = av1_refining_search_8p_c_low_precision(
- &full_ms_params, start_fullmv, &best_mv.as_fullmv);
+ &full_ms_params, start_fullmv, &best_mv.as_fullmv,
+ cpi->sf.flexmv_sf.fast_mv_refinement);
else
#endif
bestsme = av1_refining_search_8p_c(&full_ms_params, start_fullmv,
- &best_mv.as_fullmv
-#if CONFIG_FLEX_MVRES && FAST_MV_REFINEMENT > 1
- ,
- fast_mv_refinement
-#endif
- );
+ &best_mv.as_fullmv);
// Restore the pointer to the first (possibly scaled) prediction buffer.
if (id) xd->plane[plane].pre[0] = ref_yv12[0];
@@ -939,6 +936,9 @@
const MvCosts *mv_costs = &x->mv_costs;
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
+#endif
#endif
#if CONFIG_JOINT_MVD
@@ -1077,10 +1077,14 @@
#endif // CONFIG_ADAPTIVE_MVD || CONFIG_JOINT_MVD
// Make motion search params
FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
+
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize,
&ref_mv.as_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
#endif
NULL,
/*fine_search_interval=*/0);
@@ -1097,27 +1101,15 @@
// Small-range full-pixel motion search.
#if CONFIG_FLEX_MVRES
-#if FAST_MV_REFINEMENT > 1
-#if FAST_MV_REFINEMENT > 2
- const int fast_mv_refinement = (pb_mv_precision != mbmi->max_mv_precision);
-#else
- const int fast_mv_refinement = 0;
-#endif
-#endif
if (pb_mv_precision < MV_PRECISION_ONE_PEL) {
bestsme = av1_refining_search_8p_c_low_precision(
- &full_ms_params, start_fullmv, &best_mv.as_fullmv);
+ &full_ms_params, start_fullmv, &best_mv.as_fullmv,
+ cpi->sf.flexmv_sf.fast_mv_refinement);
} else {
#endif
// Small-range full-pixel motion search.
bestsme = av1_refining_search_8p_c(&full_ms_params, start_fullmv,
- &best_mv.as_fullmv
-#if CONFIG_FLEX_MVRES && FAST_MV_REFINEMENT > 1
- ,
- fast_mv_refinement
-#endif
-
- );
+ &best_mv.as_fullmv);
#if CONFIG_FLEX_MVRES
}
#endif
@@ -1406,12 +1398,18 @@
const int fine_search_interval = use_fine_search_interval(cpi);
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
+#endif
#endif
FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
#endif
src_search_sites, fine_search_interval);
#if CONFIG_FLEX_MVRES
diff --git a/av1/encoder/motion_search_facade.h b/av1/encoder/motion_search_facade.h
index a5bcb90..71cb30f 100644
--- a/av1/encoder/motion_search_facade.h
+++ b/av1/encoder/motion_search_facade.h
@@ -25,10 +25,6 @@
int64_t rd;
int drl_cost;
-#if CONFIG_FLEX_MVRES && SKIP_NEW_MV_ET
- int flex_mv_cost;
-#endif
-
int rate_mv;
int_mv mv;
@@ -40,7 +36,7 @@
BLOCK_SIZE bsize, int ref_idx, int *rate_mv,
int search_range, inter_mode_info *mode_info,
int_mv *best_mv);
-#if CONFIG_FLEX_MVRES && REUSE_PREV_MV
+#if CONFIG_FLEX_MVRES
void av1_single_motion_search_high_precision(const AV1_COMP *const cpi,
MACROBLOCK *x, BLOCK_SIZE bsize,
int ref_idx, int *rate_mv,
diff --git a/av1/encoder/mv_prec.c b/av1/encoder/mv_prec.c
index 703804e..e3998da 100644
--- a/av1/encoder/mv_prec.c
+++ b/av1/encoder/mv_prec.c
@@ -741,6 +741,11 @@
const int order_diff = order_hint - mv_stats->order;
aom_clear_system_state();
const float area = (float)(cm->width * cm->height);
+#if CONFIG_FLEX_MVRES && FAST_FLEX_MV_ENCODER && DEBUG_FLEX_MV
+ assert(AOMMIN(cm->width, cm->height) < 1080);
+ CHECK_FLEX_MV((AOMMIN(cm->width, cm->height) >= 1080),
+ "1/8-th pel should be be allowed for 1080p or larger");
+#endif
float features[MV_PREC_FEATURE_SIZE] = {
(float)current_q,
(float)mv_stats->q,
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 8da584a..eed1f45 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -829,9 +829,9 @@
#endif // CONFIG_FORWARDSKIP
}
-#if CONFIG_BVCOST_UPDATE
#if CONFIG_FLEX_MVRES
-void fill_dv_costs(IntraBCMvCosts *dv_costs, const FRAME_CONTEXT *fc) {
+void fill_dv_costs(IntraBCMvCosts *dv_costs, const FRAME_CONTEXT *fc,
+ MvCosts *mv_costs) {
dv_costs->dv_costs[0] = &dv_costs->dv_costs_alloc[0][MV_MAX];
dv_costs->dv_costs[1] = &dv_costs->dv_costs_alloc[1][MV_MAX];
av1_build_nmv_cost_table(dv_costs->joint_mv, dv_costs->dv_costs, &fc->ndvc,
@@ -841,8 +841,17 @@
0
#endif
);
-}
+
+#if CONFIG_BVCOST_UPDATE
+ // Copy the pointer of the dv cost to the mvcost
+ mv_costs->dv_joint_cost = &dv_costs->joint_mv[0];
+ mv_costs->dv_nmv_cost[0] = dv_costs->dv_costs[0];
+ mv_costs->dv_nmv_cost[1] = dv_costs->dv_costs[1];
#else
+ (void)mv_costs;
+#endif
+}
+#elif CONFIG_BVCOST_UPDATE
void av1_fill_dv_costs(const FRAME_CONTEXT *fc, IntraBCMVCosts *dv_costs) {
int *dvcost[2] = { &dv_costs->mv_component[0][MV_MAX],
&dv_costs->mv_component[1][MV_MAX] };
@@ -854,8 +863,6 @@
}
#endif
-#endif // CONFIG_BVCOST_UPDATE
-
#if CONFIG_FLEX_MVRES
void av1_fill_mv_costs(const FRAME_CONTEXT *fc, int integer_mv,
MvSubpelPrecision fr_mv_precision, MvCosts *mv_costs) {
@@ -958,7 +965,7 @@
#endif // !CONFIG_BVCOST_UPDATE
!is_stat_generation_stage(cpi)) {
#if CONFIG_FLEX_MVRES
- fill_dv_costs(&cpi->dv_costs, cm->fc);
+ fill_dv_costs(&cpi->dv_costs, cm->fc, mv_costs);
#else
IntraBCMVCosts *const dv_costs = &cpi->dv_costs;
int *dvcost[2] = { &dv_costs->mv_component[0][MV_MAX],
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index d945396..b7beaa5 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -389,13 +389,12 @@
MvCosts *mv_costs);
#endif
-#if CONFIG_BVCOST_UPDATE
#if CONFIG_FLEX_MVRES
-void fill_dv_costs(IntraBCMvCosts *dv_costs, const FRAME_CONTEXT *fc);
-#else
+void fill_dv_costs(IntraBCMvCosts *dv_costs, const FRAME_CONTEXT *fc,
+ MvCosts *mv_costs);
+#elif CONFIG_BVCOST_UPDATE
void av1_fill_dv_costs(const FRAME_CONTEXT *fc, IntraBCMVCosts *dv_costs);
#endif
-#endif
int av1_get_adaptive_rdmult(const struct AV1_COMP *cpi, double beta);
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index e5dfa02..219abe5 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -1513,7 +1513,6 @@
if (is_comp_pred) {
#if CONFIG_FLEX_MVRES
-#if REUSE_PREV_MV == 2
int valid_mv0_found = 0;
int valid_precision_mv0 = NUM_MV_PRECISIONS;
for (int prev_mv_precision = pb_mv_precision;
@@ -1538,13 +1537,6 @@
const int valid_mv0 = valid_mv0_found;
const int valid_mv1 = valid_mv1_found;
#else
-
- const int valid_mv0 =
- args->single_newmv_valid[mbmi->pb_mv_precision][ref_mv_idx][refs[0]];
- const int valid_mv1 =
- args->single_newmv_valid[mbmi->pb_mv_precision][ref_mv_idx][refs[1]];
-#endif
-#else
const int valid_mv0 = args->single_newmv_valid[ref_mv_idx][refs[0]];
const int valid_mv1 = args->single_newmv_valid[ref_mv_idx][refs[1]];
#endif
@@ -1556,14 +1548,9 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
if (valid_mv0) {
#if CONFIG_FLEX_MVRES
-#if REUSE_PREV_MV == 2
cur_mv[0].as_int =
args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
#else
- cur_mv[0].as_int =
- args->single_newmv[pb_mv_precision][ref_mv_idx][refs[0]].as_int;
-#endif
-#else
cur_mv[0].as_int = args->single_newmv[ref_mv_idx][refs[0]].as_int;
#endif
@@ -1574,14 +1561,9 @@
}
if (valid_mv1) {
#if CONFIG_FLEX_MVRES
-#if REUSE_PREV_MV == 2
cur_mv[1].as_int =
args->single_newmv[valid_precision_mv1][ref_mv_idx][refs[1]].as_int;
#else
- cur_mv[1].as_int =
- args->single_newmv[pb_mv_precision][ref_mv_idx][refs[1]].as_int;
-#endif
-#else
cur_mv[1].as_int = args->single_newmv[ref_mv_idx][refs[1]].as_int;
#endif
#if CONFIG_FLEX_MVRES
@@ -1622,14 +1604,9 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
if (valid_mv1) {
#if CONFIG_FLEX_MVRES
-#if REUSE_PREV_MV == 2
cur_mv[1].as_int =
args->single_newmv[valid_precision_mv1][ref_mv_idx][refs[1]].as_int;
#else
- cur_mv[1].as_int =
- args->single_newmv[pb_mv_precision][ref_mv_idx][refs[1]].as_int;
-#endif
-#else
cur_mv[1].as_int = args->single_newmv[ref_mv_idx][refs[1]].as_int;
#endif
#if CONFIG_FLEX_MVRES
@@ -1704,17 +1681,11 @@
) {
cur_mv[jmvd_base_ref_list].as_int =
#if CONFIG_FLEX_MVRES
-#if REUSE_PREV_MV == 2
args->single_newmv[jmvd_base_ref_list == 0 ? valid_precision_mv0
: valid_precision_mv1]
[ref_mv_idx][refs[jmvd_base_ref_list]]
.as_int;
#else
- args->single_newmv[pb_mv_precision][ref_mv_idx]
- [refs[jmvd_base_ref_list]]
- .as_int;
-#endif
-#else
args->single_newmv[ref_mv_idx][refs[jmvd_base_ref_list]].as_int;
#endif
@@ -1735,14 +1706,9 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
if (valid_mv0) {
#if CONFIG_FLEX_MVRES
-#if REUSE_PREV_MV == 2
cur_mv[0].as_int =
args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
#else
- cur_mv[0].as_int =
- args->single_newmv[pb_mv_precision][ref_mv_idx][refs[0]].as_int;
-#endif
-#else
cur_mv[0].as_int = args->single_newmv[ref_mv_idx][refs[0]].as_int;
#endif
@@ -1809,42 +1775,25 @@
// Single ref case.
const int ref_idx = 0;
int_mv best_mv;
-#if CONFIG_FLEX_MVRES && REUSE_PREV_MV
- int valid_mv0_found = 0;
+#if CONFIG_FLEX_MVRES
int valid_precision_mv0 = NUM_MV_PRECISIONS;
- int do_refine_ms = (pb_mv_precision != mbmi->max_mv_precision) &&
+ int do_refine_ms = (cpi->sf.flexmv_sf.fast_motion_search_low_precision &&
+ pb_mv_precision < mbmi->max_mv_precision) &&
is_pb_mv_precision_active(&cpi->common, mbmi, bsize);
if (do_refine_ms) {
- // for (int prev_mv_precision = mbmi->max_mv_precision; prev_mv_precision
- // > pb_mv_precision; prev_mv_precision--) {
-#if REUSE_PREV_MV == 2
+ int valid_mv0_found = 0;
for (int prev_mv_precision = pb_mv_precision;
prev_mv_precision <= mbmi->max_mv_precision; prev_mv_precision++) {
-#else
- for (int prev_mv_precision = pb_mv_precision + 1;
- prev_mv_precision <= mbmi->max_mv_precision; prev_mv_precision++) {
-#endif
if (args->single_newmv_valid[prev_mv_precision][ref_mv_idx][refs[0]]) {
valid_mv0_found = 1;
valid_precision_mv0 = prev_mv_precision;
break;
}
}
+
do_refine_ms &= valid_mv0_found;
}
-#if REUSE_PREV_MV == 1
- // reuse
- int resolution =
- AOMMAX(cm->seq_params.max_frame_width, cm->seq_params.max_frame_height);
- if (resolution < 1280)
- do_refine_ms &= (pb_mv_precision != MV_PRECISION_TWO_PEL);
- else
- do_refine_ms &= (pb_mv_precision >= MV_PRECISION_ONE_PEL); // subpel-int
-
- // do_refine_ms &= (pb_mv_precision < MV_PRECISION_ONE_PEL); // 248 reuse
-#endif
-
if (do_refine_ms) {
int_mv start_mv;
assert(valid_precision_mv0 > pb_mv_precision &&
@@ -1907,7 +1856,7 @@
}
av1_single_motion_search(cpi, x, bsize, ref_idx, rate_mv, search_range,
mode_info, &best_mv);
-#if CONFIG_FLEX_MVRES && REUSE_PREV_MV
+#if CONFIG_FLEX_MVRES
}
#endif
@@ -1948,6 +1897,20 @@
}
}
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 2
+static INLINE int skip_search_inter_intra(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi,
+ BLOCK_SIZE bsize) {
+ return (is_pb_mv_precision_active(cm, mbmi, bsize) &&
+ (mbmi->pb_mv_precision <= MV_PRECISION_FOUR_PEL));
+}
+static INLINE int skip_search_non_transalation_motion_mode(
+ const AV1_COMMON *const cm, const MB_MODE_INFO *mbmi, BLOCK_SIZE bsize) {
+ return (is_pb_mv_precision_active(cm, mbmi, bsize) &&
+ (mbmi->pb_mv_precision < mbmi->max_mv_precision));
+}
+#endif
+
/*!\brief AV1 motion mode search
*
* \ingroup inter_mode_search
@@ -2104,6 +2067,17 @@
assert(mbmi->ref_frame[1] != INTRA_FRAME);
}
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 2
+ // skip searching inter-intra for low precisions
+ if (is_interintra_mode && skip_search_inter_intra(cm, mbmi, bsize))
+ continue;
+
+ // skip searching non-transalation motion for low precisions
+ if (!is_interintra_mode && (mbmi->motion_mode != SIMPLE_TRANSLATION) &&
+ skip_search_non_transalation_motion_mode(cm, mbmi, bsize))
+ continue;
+#endif
+
// Do not search OBMC if the probability of selecting it is below a
// predetermined threshold for this update_type and block size.
const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group);
@@ -2760,10 +2734,6 @@
rd_stats->rate += drl_cost;
mode_info[ref_mv_idx].drl_cost = drl_cost;
-#if CONFIG_FLEX_MVRES && SKIP_NEW_MV_ET
- mode_info[ref_mv_idx].flex_mv_cost = flex_mv_cost;
-#endif
-
int_mv cur_mv[2];
if (!build_cur_mv(cur_mv, mbmi->mode, cm, x, 0)) {
return INT64_MAX;
@@ -2819,6 +2789,52 @@
return (mask >> index) & 0x1;
}
+#if CONFIG_FLEX_MVRES
+static int skip_similar_ref_mv(AV1_COMP *const cpi, MACROBLOCK *x,
+ BLOCK_SIZE bsize) {
+ AV1_COMMON *const cm = &cpi->common;
+ const MACROBLOCKD *const xd = &x->e_mbd;
+ const MB_MODE_INFO *const mbmi = xd->mi[0];
+ const MB_MODE_INFO_EXT *mbmi_ext = x->mbmi_ext;
+
+ if (is_pb_mv_precision_active(cm, mbmi, bsize) &&
+ (mbmi->pb_mv_precision < mbmi->max_mv_precision) &&
+ mbmi->ref_mv_idx > 0) {
+ const int is_comp_pred = has_second_ref(mbmi);
+ const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
+ int_mv this_refmv[2];
+ for (int i = 0; i < is_comp_pred + 1; ++i) {
+ this_refmv[i] =
+ (i == 0)
+ ? mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].this_mv
+ : mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx]
+ .comp_mv;
+ lower_mv_precision(&this_refmv[i].as_mv, mbmi->pb_mv_precision);
+ }
+
+ for (int prev_ref_mv_idx = 0; prev_ref_mv_idx < mbmi->ref_mv_idx;
+ prev_ref_mv_idx++) {
+ int_mv prev_refmv[2];
+ for (int i = 0; i < is_comp_pred + 1; ++i) {
+ prev_refmv[i] =
+ (i == 0) ? mbmi_ext->ref_mv_stack[ref_frame_type][prev_ref_mv_idx]
+ .this_mv
+ : mbmi_ext->ref_mv_stack[ref_frame_type][prev_ref_mv_idx]
+ .comp_mv;
+ lower_mv_precision(&prev_refmv[i].as_mv, mbmi->pb_mv_precision);
+ }
+ int prev_refmv_same_as_curr_ref_mv =
+ (this_refmv[0].as_int == prev_refmv[0].as_int);
+ if (is_comp_pred)
+ prev_refmv_same_as_curr_ref_mv &=
+ (this_refmv[1].as_int == prev_refmv[1].as_int);
+ if (prev_refmv_same_as_curr_ref_mv) return 1;
+ }
+ }
+ return 0;
+}
+#endif
+
// Before performing the full MV search in handle_inter_mode, do a simple
// translation search and see if we can eliminate any motion vectors.
// Returns an integer where, if the i-th bit is set, it means that the i-th
@@ -3161,158 +3177,6 @@
return 0;
}
-#if CONFIG_FLEX_MVRES && SKIP_NEW_MV_ET
-// If the current mode being searched is NEWMV, this function will look
-// at previously searched MVs and check if they are the same
-// as the current MV. If it finds that this MV is repeated, it compares
-// the cost to the previous MV and skips the rest of the search if it is
-// more expensive.
-static int skip_high_precision_repeated_newmv(
- AV1_COMP *const cpi, MACROBLOCK *x, BLOCK_SIZE bsize,
- const int do_tx_search, const PREDICTION_MODE this_mode,
-#if CONFIG_FLEX_MVRES
- const MvSubpelPrecision this_pb_mv_precision,
-#endif
- MB_MODE_INFO *best_mbmi, motion_mode_candidate *motion_mode_cand,
- int64_t *ref_best_rd, RD_STATS *best_rd_stats, RD_STATS *best_rd_stats_y,
- RD_STATS *best_rd_stats_uv,
- inter_mode_info mode_info[NUM_MV_PRECISIONS][MAX_REF_MV_SEARCH],
- HandleInterModeArgs *args, int drl_cost, const int *refs, int_mv *cur_mv,
- int64_t *best_rd, const BUFFER_SET orig_dst, int ref_mv_idx, int ref_set,
- const MvSubpelPrecision max_mv_precision, int flex_mv_cost) {
- // This feature only works for NEWMV when a previous mv has been searched
- if (this_mode != NEWMV || ref_mv_idx == 0) return 0;
- MACROBLOCKD *xd = &x->e_mbd;
- const AV1_COMMON *cm = &cpi->common;
- const int num_planes = av1_num_planes(cm);
-
- int skip = 0;
- int this_rate_mv = 0;
- int prev_ref_mv_idx;
- int previous_pb_mv_precision = this_pb_mv_precision;
- int tmp_prev_pb_mv_precision = this_pb_mv_precision;
- int tmp_prev_ref_mv_idx = 0;
- for (prev_ref_mv_idx = 0; prev_ref_mv_idx < ref_set && !skip;
- ++prev_ref_mv_idx) {
- for (previous_pb_mv_precision = this_pb_mv_precision && !skip;
- previous_pb_mv_precision <= max_mv_precision;
- previous_pb_mv_precision++) {
- // Search results are not available yet.
- if ((previous_pb_mv_precision == this_pb_mv_precision) &&
- prev_ref_mv_idx >= ref_mv_idx)
- continue;
-
- // if (previous_pb_mv_precision != this_pb_mv_precision)
- // continue;
-
- // Check if the motion search result same as previous results
- if (cur_mv[0].as_int == args->single_newmv[previous_pb_mv_precision]
- [prev_ref_mv_idx][refs[0]]
- .as_int &&
- args->single_newmv_valid[previous_pb_mv_precision][prev_ref_mv_idx]
- [refs[0]]) {
- //
- // printf(" same MV is found \n");
- // If the compared mode has no valid rd, it is unlikely this
- // mode will be the best mode
- if (mode_info[previous_pb_mv_precision][prev_ref_mv_idx].rd ==
- INT64_MAX) {
- skip = 1;
- tmp_prev_pb_mv_precision = previous_pb_mv_precision;
- tmp_prev_ref_mv_idx = prev_ref_mv_idx;
- goto end;
- }
- // Compare the cost difference including drl cost and mv cost
- if (mode_info[previous_pb_mv_precision][prev_ref_mv_idx].mv.as_int !=
- INVALID_MV) {
- const int compare_cost =
- mode_info[previous_pb_mv_precision][prev_ref_mv_idx]
- .flex_mv_cost +
- mode_info[previous_pb_mv_precision][prev_ref_mv_idx].rate_mv +
- mode_info[previous_pb_mv_precision][prev_ref_mv_idx].drl_cost;
- const int_mv ref_mv = av1_get_ref_mv(x, 0);
-#if CONFIG_FLEX_MVRES
- this_rate_mv = av1_mv_bit_cost(&cur_mv[0].as_mv, &ref_mv.as_mv,
- this_pb_mv_precision, &x->mv_costs,
- MV_COST_WEIGHT);
-#else
- this_rate_mv = av1_mv_bit_cost(
- &mode_info[i].mv.as_mv, &ref_mv.as_mv, x->mv_costs.nmv_joint_cost,
- x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
-#endif
- const int this_cost = this_rate_mv + drl_cost + flex_mv_cost;
-
- if (compare_cost <= this_cost) {
- // Skip this mode if it is more expensive as the previous result
- // for this MV
- skip = 1;
- tmp_prev_pb_mv_precision = previous_pb_mv_precision;
- tmp_prev_ref_mv_idx = prev_ref_mv_idx;
- goto end;
- } else {
- // If the cost is less than current best result, make this
- // the best and update corresponding variables unless the
- // best_mv is the same as ref_mv. In this case we skip and
- // rely on NEAR(EST)MV instead
- if (best_mbmi->ref_mv_idx == prev_ref_mv_idx &&
- best_mbmi->pb_mv_precision == this_pb_mv_precision &&
- best_mbmi->mv[0].as_int != ref_mv.as_int) {
- assert(*best_rd != INT64_MAX);
- assert(best_mbmi->mv[0].as_int ==
- mode_info[previous_pb_mv_precision][prev_ref_mv_idx]
- .mv.as_int);
- best_mbmi->ref_mv_idx = ref_mv_idx;
- motion_mode_cand->rate_mv = this_rate_mv;
- best_rd_stats->rate += this_cost - compare_cost;
- *best_rd =
- RDCOST(x->rdmult, best_rd_stats->rate, best_rd_stats->dist);
- // We also need to update mode_info here because we are setting
- // (ref_)best_rd here. So we will not be able to search the same
- // mode again with the current configuration.
- mode_info[this_pb_mv_precision][ref_mv_idx].mv.as_int =
- best_mbmi->mv[0].as_int;
- mode_info[this_pb_mv_precision][ref_mv_idx].rate_mv =
- this_rate_mv;
- mode_info[this_pb_mv_precision][ref_mv_idx].rd = *best_rd;
- if (*best_rd < *ref_best_rd) *ref_best_rd = *best_rd;
- // break;
- // return 0;
- goto end;
- }
- }
- }
- }
- }
- }
-
-end:
- if (skip) {
- const THR_MODES mode_enum = get_prediction_mode_idx(
- best_mbmi->mode, best_mbmi->ref_frame[0], best_mbmi->ref_frame[1]);
- // Collect mode stats for multiwinner mode processing
- store_winner_mode_stats(
- &cpi->common, x, best_mbmi, best_rd_stats, best_rd_stats_y,
- best_rd_stats_uv, mode_enum, NULL, bsize, *best_rd,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, do_tx_search);
- args->modelled_rd[this_mode][ref_mv_idx][refs[0]] =
- args->modelled_rd[this_mode][tmp_prev_ref_mv_idx][refs[0]];
- args->simple_rd[this_mode][ref_mv_idx][refs[0]] =
- args->simple_rd[this_mode][tmp_prev_ref_mv_idx][refs[0]];
-
- mode_info[this_pb_mv_precision][ref_mv_idx].rd =
- mode_info[tmp_prev_pb_mv_precision][tmp_prev_ref_mv_idx].rd;
- mode_info[this_pb_mv_precision][ref_mv_idx].rate_mv = this_rate_mv;
- mode_info[this_pb_mv_precision][ref_mv_idx].mv.as_int =
- mode_info[tmp_prev_pb_mv_precision][tmp_prev_ref_mv_idx].mv.as_int;
-
- restore_dst_buf(xd, orig_dst, num_planes);
- return 1;
- }
- return 0;
-}
-
-#endif
-
// If the current mode being searched is NEWMV, this function will look
// at previously searched MVs and check if they are the same
// as the current MV. If it finds that this MV is repeated, it compares
@@ -3503,7 +3367,12 @@
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
// Find matching interp filter or set to default interp filter
- const int need_search = av1_is_interp_needed(cm, xd);
+ const int need_search =
+ av1_is_interp_needed(cm, xd)
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 2
+ && !skip_interpolation_filter_search_precision(cm, mbmi, bsize)
+#endif
+ ;
const InterpFilter assign_filter = cm->features.interp_filter;
int is_luma_interp_done = 0;
av1_find_interp_filter_match(mbmi, cpi, assign_filter, need_search,
@@ -3581,201 +3450,6 @@
return 0;
}
-#if CONFIG_FLEX_MVRES && MODEL_RDO_BASED_SEARCH
-static int64_t handle_all_mv_precisions(
- AV1_COMP *const cpi, MACROBLOCK *const x, const BLOCK_SIZE bsize,
- int ref_mv_idx, int_mv *cur_mv, HandleInterModeArgs *const args,
- inter_mode_info mode_info[NUM_MV_PRECISIONS][MAX_REF_MV_SEARCH],
- const int drl_cost, int idx_mask[NUM_MV_PRECISIONS],
- PrecisionStats pb_mv_precision_stats[NUM_MV_PRECISIONS],
- const int base_rate, const int flex_mv_cost[NUM_MV_PRECISIONS]) {
- const AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- int rate_mv = 0;
- int total_rate = 0;
- const PREDICTION_MODE this_mode = mbmi->mode;
- const int is_comp_pred = has_second_ref(mbmi);
-
- struct macroblockd_plane *p = xd->plane;
- const BUFFER_SET orig_dst = {
- { p[0].dst.buf, p[1].dst.buf, p[2].dst.buf },
- { p[0].dst.stride, p[1].dst.stride, p[2].dst.stride },
- };
-
-#if ADAPTIVE_PRECISION_SETS
- const PRECISION_SET *precision_def =
- &av1_mv_precision_sets[mbmi->mb_precision_set];
- for (int precision_dx = precision_def->num_precisions - 1; precision_dx >= 0;
- precision_dx--) {
- MvSubpelPrecision pb_mv_precision = precision_def->precision[precision_dx];
- assert(pb_mv_precision <= mbmi->max_mv_precision);
-#else
- for (int pb_mv_precision = mbmi->max_mv_precision;
- pb_mv_precision >= MV_PRECISION_8_PEL; pb_mv_precision--) {
-#endif
- mbmi->pb_mv_precision = pb_mv_precision;
- pb_mv_precision_stats[mbmi->pb_mv_precision].model_rd = INT64_MAX;
- if (!is_pb_mv_precision_active(cm, mbmi, bsize) &&
- (pb_mv_precision != mbmi->max_mv_precision)) {
- continue;
- }
- pb_mv_precision_stats[mbmi->pb_mv_precision].skip_this_precision = 0;
- pb_mv_precision_stats[mbmi->pb_mv_precision].cur_mv[0].as_int =
- cur_mv[0].as_int;
- pb_mv_precision_stats[mbmi->pb_mv_precision].cur_mv[1].as_int =
- cur_mv[1].as_int;
- pb_mv_precision_stats[mbmi->pb_mv_precision].newmv_ret_val = INT64_MAX;
-
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].full_search_mv.as_int =
- INVALID_MV;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int = INVALID_MV;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = INT64_MAX;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].drl_cost = drl_cost;
- if (!mask_check_bit(idx_mask[mbmi->pb_mv_precision], ref_mv_idx)) {
- // MV did not perform well in simple translation search. Skip it.
- pb_mv_precision_stats[mbmi->pb_mv_precision].skip_this_precision = 1;
- continue;
- }
-
- // The above call to build_cur_mv does not handle NEWMV modes. Build
- // the mv here if we have NEWMV for any predictors.
- if (have_newmv_in_inter_mode(this_mode)) {
- pb_mv_precision_stats[mbmi->pb_mv_precision].newmv_ret_val =
- handle_newmv(cpi, x, bsize,
- &pb_mv_precision_stats[mbmi->pb_mv_precision].cur_mv[0],
- &rate_mv, args, mode_info[mbmi->pb_mv_precision]);
- pb_mv_precision_stats[mbmi->pb_mv_precision].rate_mv = rate_mv;
- if (pb_mv_precision_stats[mbmi->pb_mv_precision].newmv_ret_val != 0)
- continue;
- }
-
- // Compute the model RD cost
- if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
- // Build the inter predictor and compute the model RD
- // Copy the motion vector for this mode into mbmi struct
- for (int i = 0; i < is_comp_pred + 1; ++i) {
- mbmi->mv[i].as_int =
- pb_mv_precision_stats[mbmi->pb_mv_precision].cur_mv[i].as_int;
- }
-
- mbmi->interinter_comp.type = COMPOUND_AVERAGE;
- mbmi->comp_group_idx = 0;
- if (mbmi->ref_frame[1] == INTRA_FRAME) mbmi->ref_frame[1] = NONE_FRAME;
- mbmi->num_proj_ref = 0;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->ref_mv_idx = ref_mv_idx;
- set_default_interp_filters(mbmi,
-#if CONFIG_OPTFLOW_REFINEMENT
- cm,
-#endif // CONFIG_OPTFLOW_REFINEMENT
- cm->features.interp_filter);
-
- // Build this inter predictor
- av1_enc_build_inter_predictor(cm, xd, xd->mi_row, xd->mi_col, &orig_dst,
- bsize, 0, av1_num_planes(cm) - 1);
- int est_rate;
- int64_t est_dist;
- model_rd_sb_fn[MODELRD_CURVFIT](cpi, bsize, x, xd, 0, 0, &est_rate,
- &est_dist, NULL, NULL, NULL, NULL, NULL);
-
- total_rate = base_rate + drl_cost + flex_mv_cost[mbmi->pb_mv_precision] +
- est_rate +
- pb_mv_precision_stats[mbmi->pb_mv_precision].rate_mv;
- pb_mv_precision_stats[mbmi->pb_mv_precision].model_rd =
- RDCOST(x->rdmult, total_rate, est_dist);
- }
- }
-
- // Motion search is done so we can return if flex MV is not enabled
- if (!is_pb_mv_precision_active(cm, mbmi, bsize)) return 0;
-
-#if 0 // ADAPTIVE_PRECISION_SETS
- return 0;
-#endif
-
- // Analyze the RD cost values
- int64_t tmp_rd_costs[NUM_MV_PRECISIONS];
- int64_t tmp_precison_value[NUM_MV_PRECISIONS];
- int number_of_candidates = 2;
-
-#if ADAPTIVE_PRECISION_SETS
- int number_mv_precisions = precision_def->num_precisions;
- for (int precision_dx = 0; precision_dx < number_mv_precisions;
- precision_dx++) {
- MvSubpelPrecision pb_mv_precision = precision_def->precision[precision_dx];
- assert(pb_mv_precision <= mbmi->max_mv_precision);
- tmp_precison_value[precision_dx] = pb_mv_precision;
- tmp_rd_costs[precision_dx] =
- pb_mv_precision_stats[pb_mv_precision].model_rd;
-#else
- int number_mv_precisions = mbmi->max_mv_precision + 1;
- for (int pb_mv_precision = 0; pb_mv_precision < number_mv_precisions;
- pb_mv_precision++) {
- tmp_precison_value[pb_mv_precision] = pb_mv_precision;
- tmp_rd_costs[pb_mv_precision] =
- pb_mv_precision_stats[pb_mv_precision].model_rd;
-#endif
- }
-
- // Bubble sorting
- int i, j;
-
-#if 0
- printf("Before sorting: ");
- for (i = 0; i < number_mv_precisions; ++i)
- printf(" % li", tmp_rd_costs[i]);
- printf("\n");
- printf("Before sorting index: ");
- for (i = 0; i < number_mv_precisions; ++i)
- printf(" % li", tmp_precison_value[i]);
- printf("\n");
-#endif
-
- for (i = 0; i < number_mv_precisions; ++i) {
- for (j = i + 1; j < number_mv_precisions; ++j) {
- if (tmp_rd_costs[i] >= tmp_rd_costs[j]) {
- int64_t a = tmp_rd_costs[i];
- tmp_rd_costs[i] = tmp_rd_costs[j];
- tmp_rd_costs[j] = a;
-
- int idx = tmp_precison_value[i];
- tmp_precison_value[i] = tmp_precison_value[j];
- tmp_precison_value[j] = idx;
- }
- }
- }
-
-#if 0
- printf("After sorting rdcost : ");
- for (i = 0; i < number_mv_precisions; ++i)
- printf(" % li", tmp_rd_costs[i]);
- printf("\n");
-
- printf("After sorting index: ");
- for (i = 0; i < number_mv_precisions; ++i)
- printf(" % li", tmp_precison_value[i]);
- printf("\n");
-#endif
-
- for (i = 0; i < number_mv_precisions; ++i) {
- MvSubpelPrecision pb_mv_precision = tmp_precison_value[i];
- int force_skip =
- (pb_mv_precision != mbmi->max_mv_precision &&
- pb_mv_precision_stats[pb_mv_precision].model_rd == INT64_MAX);
- // if (!(pb_mv_precision == mbmi->max_mv_precision || i <
- // number_of_candidates)) {
-
- if (i >= number_of_candidates || force_skip) {
- pb_mv_precision_stats[pb_mv_precision].skip_this_precision = 1;
- }
- }
-
- return 0;
-}
-
-#endif
-
/*!\brief AV1 inter mode RD computation
*
* \ingroup inter_mode_search
@@ -3895,9 +3569,7 @@
TX_TYPE best_tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
MB_MODE_INFO best_mbmi = *mbmi;
int best_xskip_txfm = 0;
-#if !CONFIG_FLEX_MVRES || !MODEL_RDO_BASED_SEARCH
int64_t newmv_ret_val = INT64_MAX;
-#endif
#if CONFIG_FLEX_MVRES
inter_mode_info mode_info[NUM_MV_PRECISIONS][MAX_REF_MV_SEARCH];
#else
@@ -3923,17 +3595,6 @@
// Save MV results from first 2 ref_mv_idx.
#if CONFIG_FLEX_MVRES
int_mv save_mv[NUM_MV_PRECISIONS][MAX_REF_MV_SEARCH - 1][2];
-
-#if SKIP_NEW_MV_ET
- for (int j = mbmi->max_mv_precision; j >= MV_PRECISION_8_PEL; j--) {
- for (int k = 0; k < ref_set; ++k) {
- mode_info[j][k].full_search_mv.as_int = INVALID_MV;
- mode_info[j][k].mv.as_int = INVALID_MV;
- mode_info[j][k].rd = INT64_MAX;
- }
- }
-#endif
-
#else
int_mv save_mv[MAX_REF_MV_SEARCH - 1][2];
#endif
@@ -4056,8 +3717,9 @@
const int drl_cost =
get_drl_cost(cm->features.max_drl_bits, mbmi, mbmi_ext, x);
-#if CONFIG_FLEX_MVRES && !MODEL_RDO_BASED_SEARCH
-
+#if CONFIG_FLEX_MVRES
+ MvSubpelPrecision best_precision_so_far = mbmi->max_mv_precision;
+ int64_t best_precision_rd_so_far = INT64_MAX;
#if ADAPTIVE_PRECISION_SETS
set_precision_set(cm, xd, mbmi, bsize, ref_mv_idx);
const PRECISION_SET *precision_def =
@@ -4079,6 +3741,22 @@
continue;
}
+ if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
+ if (cpi->sf.flexmv_sf.terminate_early_4_pel_precision &&
+ pb_mv_precision < MV_PRECISION_FOUR_PEL &&
+ best_precision_so_far >= MV_PRECISION_QTR_PEL)
+ continue;
+ if (mbmi->ref_mv_idx) {
+ if (cpi->sf.flexmv_sf.do_not_search_8_pel_precision &&
+ mbmi->pb_mv_precision == MV_PRECISION_8_PEL)
+ continue;
+
+ if (cpi->sf.flexmv_sf.do_not_search_4_pel_precision &&
+ mbmi->pb_mv_precision == MV_PRECISION_FOUR_PEL)
+ continue;
+ }
+ }
+
#endif
#endif
@@ -4127,81 +3805,54 @@
if (!build_cur_mv(cur_mv, this_mode, cm, x, skip_repeated_ref_mv)) {
continue;
}
-
-#if CONFIG_FLEX_MVRES && MODEL_RDO_BASED_SEARCH
- PrecisionStats pb_mv_precision_stats[NUM_MV_PRECISIONS];
- handle_all_mv_precisions(cpi, x, bsize, ref_mv_idx, &cur_mv[0], args,
- mode_info, drl_cost, idx_mask,
- pb_mv_precision_stats, base_rate, flex_mv_cost);
-#else
#if CONFIG_FLEX_MVRES
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].full_search_mv.as_int =
- INVALID_MV;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int = INVALID_MV;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = INT64_MAX;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].drl_cost = drl_cost;
-#if SKIP_NEW_MV_ET
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].flex_mv_cost =
- flex_mv_cost[mbmi->pb_mv_precision];
-#endif
- if (!mask_check_bit(idx_mask[mbmi->pb_mv_precision], ref_mv_idx)) {
- // MV did not perform well in simple translation search. Skip it.
- continue;
- }
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].full_search_mv.as_int =
+ INVALID_MV;
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int = INVALID_MV;
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = INT64_MAX;
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].drl_cost = drl_cost;
+ if (!mask_check_bit(idx_mask[mbmi->pb_mv_precision], ref_mv_idx)) {
+ // MV did not perform well in simple translation search. Skip it.
+ continue;
+ }
+ if (cpi->sf.flexmv_sf.skip_similar_ref_mv &&
+ skip_similar_ref_mv(cpi, x, bsize)) {
+ continue;
+ }
#endif
- // The above call to build_cur_mv does not handle NEWMV modes. Build
- // the mv here if we have NEWMV for any predictors.
- if (have_newmv_in_inter_mode(this_mode)) {
+ // The above call to build_cur_mv does not handle NEWMV modes. Build
+ // the mv here if we have NEWMV for any predictors.
+ if (have_newmv_in_inter_mode(this_mode)) {
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, handle_newmv_time);
+ start_timing(cpi, handle_newmv_time);
#endif
- newmv_ret_val = handle_newmv(cpi, x, bsize, cur_mv, &rate_mv, args,
+ newmv_ret_val = handle_newmv(cpi, x, bsize, cur_mv, &rate_mv, args,
#if CONFIG_FLEX_MVRES
- mode_info[mbmi->pb_mv_precision]);
+ mode_info[mbmi->pb_mv_precision]);
#else
mode_info);
#endif
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, handle_newmv_time);
+ end_timing(cpi, handle_newmv_time);
#endif
- if (newmv_ret_val != 0) continue;
+ if (newmv_ret_val != 0) continue;
- // skip NEWMV mode in drl if the motion search result is the same
- // as a previous result
+ // skip NEWMV mode in drl if the motion search result is the same
+ // as a previous result
#if CONFIG_FLEX_MVRES
-#if SKIP_NEW_MV_ET
-#if ENABLE_SKIP_NEW_MV_FOR_HIGH_PRECISIONS
- int skip_new_mv = cpi->sf.inter_sf.skip_repeated_newmv ||
- (mbmi->pb_mv_precision != mbmi->max_mv_precision);
- if (skip_new_mv &&
-#else
- if (cpi->sf.inter_sf.skip_repeated_newmv &&
-#endif
- skip_high_precision_repeated_newmv(
- cpi, x, bsize, do_tx_search, this_mode, mbmi->pb_mv_precision,
- &best_mbmi, motion_mode_cand, &ref_best_rd, &best_rd_stats,
- &best_rd_stats_y, &best_rd_stats_uv, mode_info, args, drl_cost,
- refs, cur_mv, &best_rd, orig_dst, ref_mv_idx, ref_set,
- mbmi->max_mv_precision, flex_mv_cost[mbmi->pb_mv_precision]))
-#else
-
-#if ENABLE_SKIP_NEW_MV_FOR_HIGH_PRECISIONS
- int skip_new_mv = cpi->sf.inter_sf.skip_repeated_newmv ||
- (mbmi->pb_mv_precision != mbmi->max_mv_precision);
- if (skip_new_mv &&
-#else
- if (cpi->sf.inter_sf.skip_repeated_newmv &&
-#endif
- skip_repeated_newmv(cpi, x, bsize, do_tx_search, this_mode,
- mbmi->pb_mv_precision, &best_mbmi,
- motion_mode_cand, &ref_best_rd, &best_rd_stats,
- &best_rd_stats_y, &best_rd_stats_uv,
- mode_info[mbmi->pb_mv_precision], args, drl_cost,
- refs, cur_mv, &best_rd, orig_dst, ref_mv_idx))
-#endif
+ int skip_new_mv = cpi->sf.inter_sf.skip_repeated_newmv ||
+ (mbmi->pb_mv_precision != mbmi->max_mv_precision &&
+ cpi->sf.flexmv_sf.skip_repeated_newmv_low_prec);
+ if (skip_new_mv &&
+ skip_repeated_newmv(
+ cpi, x, bsize, do_tx_search, this_mode, mbmi->pb_mv_precision,
+ &best_mbmi, motion_mode_cand, &ref_best_rd, &best_rd_stats,
+ &best_rd_stats_y, &best_rd_stats_uv,
+ mode_info[mbmi->pb_mv_precision], args, drl_cost, refs, cur_mv,
+ &best_rd, orig_dst, ref_mv_idx))
#else
if (cpi->sf.inter_sf.skip_repeated_newmv &&
skip_repeated_newmv(cpi, x, bsize, do_tx_search, this_mode,
@@ -4210,276 +3861,232 @@
&best_rd_stats_uv, mode_info, args, drl_cost,
refs, cur_mv, &best_rd, orig_dst, ref_mv_idx))
#endif
- continue;
- }
-
-#endif
+ continue;
+ }
#if CONFIG_FLEX_MVRES
-#if MODEL_RDO_BASED_SEARCH
+ av1_init_rd_stats(rd_stats);
+ // Initialize compound mode data
+ mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+ mbmi->comp_group_idx = 0;
+ if (mbmi->ref_frame[1] == INTRA_FRAME) mbmi->ref_frame[1] = NONE_FRAME;
-#if ADAPTIVE_PRECISION_SETS
- for (int precision_dx = precision_def->num_precisions - 1;
- precision_dx >= 0; precision_dx--) {
- MvSubpelPrecision pb_mv_precision =
- precision_def->precision[precision_dx];
- assert(pb_mv_precision <= mbmi->max_mv_precision);
-#else
- for (int pb_mv_precision = mbmi->max_mv_precision;
- pb_mv_precision >= MV_PRECISION_8_PEL; pb_mv_precision--) {
-#endif
- mbmi->pb_mv_precision = pb_mv_precision;
- if (!is_pb_mv_precision_active(cm, mbmi, bsize) &&
- (pb_mv_precision != mbmi->max_mv_precision)) {
- continue;
- }
- if (pb_mv_precision_stats[mbmi->pb_mv_precision].skip_this_precision)
- continue;
+ mbmi->num_proj_ref = 0;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->ref_mv_idx = ref_mv_idx;
-#if MODEL_RDO_BASED_SEARCH
- if (have_newmv_in_inter_mode(this_mode)) {
- rate_mv = pb_mv_precision_stats[mbmi->pb_mv_precision].rate_mv;
- cur_mv[0].as_int =
- pb_mv_precision_stats[mbmi->pb_mv_precision].cur_mv[0].as_int;
- cur_mv[1].as_int =
- pb_mv_precision_stats[mbmi->pb_mv_precision].cur_mv[1].as_int;
- if (pb_mv_precision_stats[mbmi->pb_mv_precision].newmv_ret_val != 0)
- continue;
- if (cpi->sf.inter_sf.skip_repeated_newmv &&
- skip_repeated_newmv(
- cpi, x, bsize, do_tx_search, this_mode, mbmi->pb_mv_precision,
- &best_mbmi, motion_mode_cand, &ref_best_rd, &best_rd_stats,
- &best_rd_stats_y, &best_rd_stats_uv,
- mode_info[mbmi->pb_mv_precision], args, drl_cost, refs,
- cur_mv, &best_rd, orig_dst, ref_mv_idx))
- continue;
- }
+ // Compute cost for signalling this DRL index
+ rd_stats->rate = base_rate;
+ rd_stats->rate += flex_mv_cost[mbmi->pb_mv_precision];
+ rd_stats->rate += drl_cost;
#endif
-#endif
- av1_init_rd_stats(rd_stats);
- // Initialize compound mode data
- mbmi->interinter_comp.type = COMPOUND_AVERAGE;
- mbmi->comp_group_idx = 0;
- if (mbmi->ref_frame[1] == INTRA_FRAME) mbmi->ref_frame[1] = NONE_FRAME;
+ rd_stats->rate += rate_mv;
- mbmi->num_proj_ref = 0;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->ref_mv_idx = ref_mv_idx;
-
- // Compute cost for signalling this DRL index
- rd_stats->rate = base_rate;
- rd_stats->rate += flex_mv_cost[mbmi->pb_mv_precision];
- rd_stats->rate += drl_cost;
-#endif
-
- rd_stats->rate += rate_mv;
-
- // Copy the motion vector for this mode into mbmi struct
- for (i = 0; i < is_comp_pred + 1; ++i) {
- mbmi->mv[i].as_int = cur_mv[i].as_int;
- }
+ // Copy the motion vector for this mode into mbmi struct
+ for (i = 0; i < is_comp_pred + 1; ++i) {
+ mbmi->mv[i].as_int = cur_mv[i].as_int;
+ }
#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
- CHECK_FLEX_MV(check_mv_precision(cm, mbmi) == 0,
- " precision and MV mismatch after handle_newmv");
+ CHECK_FLEX_MV(check_mv_precision(cm, mbmi) == 0,
+ " precision and MV mismatch after handle_newmv");
#endif // CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
#if CONFIG_DERIVED_MV
- mbmi->derived_mv_allowed = av1_derived_mv_allowed(xd, mbmi);
- if (mbmi->derived_mv_allowed && mbmi->ref_mv_idx == 0) {
- for (int ref = 0; ref < 1 + is_comp_pred; ++ref) {
- mbmi->derived_mv[ref] =
- av1_derive_mv(cm, xd, ref, mbmi, x->mbmi_ext->ref_mv_count,
- orig_dst.plane[0], orig_dst.stride[0]);
- }
- RD_STATS tmp_rd_stats, tmp_rd_stats_y, tmp_rd_stats_uv;
- av1_enc_build_inter_predictor(cm, xd, xd->mi_row, xd->mi_col,
- &orig_dst, bsize, 0,
- av1_num_planes(cm) - 1);
- int rd_valid = av1_txfm_search(
- cpi, x, bsize, &tmp_rd_stats, &tmp_rd_stats_y, &tmp_rd_stats_uv,
- mode_costs->use_derived_mv_cost[is_comp_pred][bsize][0],
- INT64_MAX);
- const int64_t no_refine_rd =
- rd_valid ? RDCOST(x->rdmult, tmp_rd_stats.rate, tmp_rd_stats.dist)
- : INT64_MAX;
+ mbmi->derived_mv_allowed = av1_derived_mv_allowed(xd, mbmi);
+ if (mbmi->derived_mv_allowed && mbmi->ref_mv_idx == 0) {
+ for (int ref = 0; ref < 1 + is_comp_pred; ++ref) {
+ mbmi->derived_mv[ref] =
+ av1_derive_mv(cm, xd, ref, mbmi, x->mbmi_ext->ref_mv_count,
+ orig_dst.plane[0], orig_dst.stride[0]);
+ }
+ RD_STATS tmp_rd_stats, tmp_rd_stats_y, tmp_rd_stats_uv;
+ av1_enc_build_inter_predictor(cm, xd, xd->mi_row, xd->mi_col, &orig_dst,
+ bsize, 0, av1_num_planes(cm) - 1);
+ int rd_valid = av1_txfm_search(
+ cpi, x, bsize, &tmp_rd_stats, &tmp_rd_stats_y, &tmp_rd_stats_uv,
+ mode_costs->use_derived_mv_cost[is_comp_pred][bsize][0], INT64_MAX);
+ const int64_t no_refine_rd =
+ rd_valid ? RDCOST(x->rdmult, tmp_rd_stats.rate, tmp_rd_stats.dist)
+ : INT64_MAX;
+ mbmi->use_derived_mv = 1;
+ av1_enc_build_inter_predictor(cm, xd, xd->mi_row, xd->mi_col, &orig_dst,
+ bsize, 0, av1_num_planes(cm) - 1);
+ rd_valid = av1_txfm_search(
+ cpi, x, bsize, &tmp_rd_stats, &tmp_rd_stats_y, &tmp_rd_stats_uv,
+ mode_costs->use_derived_mv_cost[is_comp_pred][bsize][1], INT64_MAX);
+ const int64_t refine_rd =
+ rd_valid ? RDCOST(x->rdmult, tmp_rd_stats.rate, tmp_rd_stats.dist)
+ : INT64_MAX;
+ if (refine_rd < no_refine_rd) {
mbmi->use_derived_mv = 1;
- av1_enc_build_inter_predictor(cm, xd, xd->mi_row, xd->mi_col,
- &orig_dst, bsize, 0,
- av1_num_planes(cm) - 1);
- rd_valid = av1_txfm_search(
- cpi, x, bsize, &tmp_rd_stats, &tmp_rd_stats_y, &tmp_rd_stats_uv,
- mode_costs->use_derived_mv_cost[is_comp_pred][bsize][1],
- INT64_MAX);
- const int64_t refine_rd =
- rd_valid ? RDCOST(x->rdmult, tmp_rd_stats.rate, tmp_rd_stats.dist)
- : INT64_MAX;
- if (refine_rd < no_refine_rd) {
- mbmi->use_derived_mv = 1;
- } else {
- mbmi->use_derived_mv = 0;
- }
} else {
mbmi->use_derived_mv = 0;
}
- if (mbmi->derived_mv_allowed) {
- rd_stats->rate +=
- mode_costs->use_derived_mv_cost[is_comp_pred][bsize]
- [mbmi->use_derived_mv];
- if (mbmi->use_derived_mv) {
- rd_stats->rate -= drl_cost;
- }
+ } else {
+ mbmi->use_derived_mv = 0;
+ }
+ if (mbmi->derived_mv_allowed) {
+ rd_stats->rate += mode_costs->use_derived_mv_cost[is_comp_pred][bsize]
+ [mbmi->use_derived_mv];
+ if (mbmi->use_derived_mv) {
+ rd_stats->rate -= drl_cost;
}
+ }
#endif // CONFIG_DERIVED_MV
- const int like_nearest = (mbmi->mode == NEARMV ||
+ const int like_nearest = (mbmi->mode == NEARMV ||
#if CONFIG_OPTFLOW_REFINEMENT
- mbmi->mode == NEAR_NEARMV_OPTFLOW ||
+ mbmi->mode == NEAR_NEARMV_OPTFLOW ||
#endif // CONFIG_OPTFLOW_REFINEMENT
- mbmi->mode == NEAR_NEARMV) &&
- mbmi->ref_mv_idx == 0;
- if (RDCOST(x->rdmult, rd_stats->rate, 0) > ref_best_rd &&
- !like_nearest) {
- continue;
- }
+ mbmi->mode == NEAR_NEARMV) &&
+ mbmi->ref_mv_idx == 0;
+ if (RDCOST(x->rdmult, rd_stats->rate, 0) > ref_best_rd && !like_nearest) {
+ continue;
+ }
- // Skip the rest of the search if prune_ref_mv_idx_search speed feature
- // is enabled, and the current MV is similar to a previous one.
- if (cpi->sf.inter_sf.prune_ref_mv_idx_search && is_comp_pred &&
- prune_ref_mv_idx_search(&cm->features, ref_mv_idx, best_ref_mv_idx,
+ // Skip the rest of the search if prune_ref_mv_idx_search speed feature
+ // is enabled, and the current MV is similar to a previous one.
+ if (cpi->sf.inter_sf.prune_ref_mv_idx_search && is_comp_pred &&
+ prune_ref_mv_idx_search(&cm->features, ref_mv_idx, best_ref_mv_idx,
#if CONFIG_FLEX_MVRES
- save_mv[mbmi->pb_mv_precision], mbmi,
+ save_mv[mbmi->pb_mv_precision], mbmi,
#else
save_mv, mbmi,
#endif
- cpi->sf.inter_sf.prune_ref_mv_idx_search))
- continue;
+ cpi->sf.inter_sf.prune_ref_mv_idx_search))
+ continue;
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, compound_type_rd_time);
+ start_timing(cpi, compound_type_rd_time);
#endif
- int skip_build_pred = 0;
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
+ int skip_build_pred = 0;
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
- // Handle a compound predictor, continue if it is determined this
- // cannot be the best compound mode
- if (is_comp_pred
+ // Handle a compound predictor, continue if it is determined this
+ // cannot be the best compound mode
+ if (is_comp_pred
#if IMPROVED_AMVD && CONFIG_JOINT_MVD
- && !is_joint_amvd_coding_mode(mbmi->mode)
+ && !is_joint_amvd_coding_mode(mbmi->mode)
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
- ) {
- const int not_best_mode = process_compound_inter_mode(
- cpi, x, args, ref_best_rd, cur_mv, bsize,
- &compmode_interinter_cost, rd_buffers, &orig_dst, &tmp_dst,
- &rate_mv, rd_stats, skip_rd, &skip_build_pred);
- if (not_best_mode) continue;
- }
+ ) {
+ const int not_best_mode = process_compound_inter_mode(
+ cpi, x, args, ref_best_rd, cur_mv, bsize, &compmode_interinter_cost,
+ rd_buffers, &orig_dst, &tmp_dst, &rate_mv, rd_stats, skip_rd,
+ &skip_build_pred);
+ if (not_best_mode) continue;
+ }
#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
- CHECK_FLEX_MV(check_mv_precision(cm, mbmi) == 0,
- " precision and MV mismatch at the end of the "
- "process_compound_inter_mode");
+ CHECK_FLEX_MV(check_mv_precision(cm, mbmi) == 0,
+ " precision and MV mismatch at the end of the "
+ "process_compound_inter_mode");
#endif
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, compound_type_rd_time);
+ end_timing(cpi, compound_type_rd_time);
#endif
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, interpolation_filter_search_time);
+ start_timing(cpi, interpolation_filter_search_time);
#endif
- // Determine the interpolation filter for this mode
- ret_val = av1_interpolation_filter_search(
- x, cpi, tile_data, bsize, &tmp_dst, &orig_dst, &rd, &rs,
- &skip_build_pred, args, ref_best_rd);
+ // Determine the interpolation filter for this mode
+ ret_val = av1_interpolation_filter_search(
+ x, cpi, tile_data, bsize, &tmp_dst, &orig_dst, &rd, &rs,
+ &skip_build_pred, args, ref_best_rd);
#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
- CHECK_FLEX_MV(check_mv_precision(cm, mbmi) == 0,
- " precision and MV mismatch at the end of the "
- "av1_interpolation_filter_search");
+ CHECK_FLEX_MV(check_mv_precision(cm, mbmi) == 0,
+ " precision and MV mismatch at the end of the "
+ "av1_interpolation_filter_search");
#endif
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, interpolation_filter_search_time);
+ end_timing(cpi, interpolation_filter_search_time);
#endif
- if (args->modelled_rd != NULL && !is_comp_pred) {
- args->modelled_rd[this_mode][ref_mv_idx][refs[0]] = rd;
- }
- if (ret_val != 0) {
- restore_dst_buf(xd, orig_dst, num_planes);
- continue;
- } else if (cpi->sf.inter_sf.model_based_post_interp_filter_breakout &&
- ref_best_rd != INT64_MAX && (rd >> 3) * 3 > ref_best_rd) {
- restore_dst_buf(xd, orig_dst, num_planes);
- continue;
- }
+ if (args->modelled_rd != NULL && !is_comp_pred) {
+ args->modelled_rd[this_mode][ref_mv_idx][refs[0]] = rd;
+ }
+ if (ret_val != 0) {
+ restore_dst_buf(xd, orig_dst, num_planes);
+ continue;
+ } else if (cpi->sf.inter_sf.model_based_post_interp_filter_breakout &&
+ ref_best_rd != INT64_MAX && (rd >> 3) * 3 > ref_best_rd) {
+ restore_dst_buf(xd, orig_dst, num_planes);
+ continue;
+ }
- // Compute modelled RD if enabled
- if (args->modelled_rd != NULL) {
+ // Compute modelled RD if enabled
+ if (args->modelled_rd != NULL) {
#if CONFIG_OPTFLOW_REFINEMENT
- if (is_comp_pred && this_mode < NEAR_NEARMV_OPTFLOW) {
+ if (is_comp_pred && this_mode < NEAR_NEARMV_OPTFLOW) {
#else
if (is_comp_pred) {
#endif // CONFIG_OPTFLOW_REFINEMENT
- const int mode0 = compound_ref0_mode(this_mode);
- const int mode1 = compound_ref1_mode(this_mode);
- const int64_t mrd =
- AOMMIN(args->modelled_rd[mode0][ref_mv_idx][refs[0]],
- args->modelled_rd[mode1][ref_mv_idx][refs[1]]);
+ const int mode0 = compound_ref0_mode(this_mode);
+ const int mode1 = compound_ref1_mode(this_mode);
+ const int64_t mrd =
+ AOMMIN(args->modelled_rd[mode0][ref_mv_idx][refs[0]],
+ args->modelled_rd[mode1][ref_mv_idx][refs[1]]);
- if ((rd >> 3) * 6 > mrd && ref_best_rd < INT64_MAX) {
- restore_dst_buf(xd, orig_dst, num_planes);
- continue;
- }
+ if ((rd >> 3) * 6 > mrd && ref_best_rd < INT64_MAX) {
+ restore_dst_buf(xd, orig_dst, num_planes);
+ continue;
}
}
- rd_stats->rate += compmode_interinter_cost;
- if (skip_build_pred != 1) {
- // Build this inter predictor if it has not been previously built
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst,
- bsize, 0, av1_num_planes(cm) - 1);
- }
+ }
+ rd_stats->rate += compmode_interinter_cost;
+ if (skip_build_pred != 1) {
+ // Build this inter predictor if it has not been previously built
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, bsize,
+ 0, av1_num_planes(cm) - 1);
+ }
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, motion_mode_rd_time);
+ start_timing(cpi, motion_mode_rd_time);
#endif
- int rate2_nocoeff = rd_stats->rate;
- // Determine the motion mode. This will be one of SIMPLE_TRANSLATION,
- // OBMC_CAUSAL or WARPED_CAUSAL
- ret_val = motion_mode_rd(cpi, tile_data, x, bsize, rd_stats, rd_stats_y,
- rd_stats_uv, args, ref_best_rd, skip_rd,
- &rate_mv, &orig_dst, best_est_rd, do_tx_search,
- inter_modes_info, 0);
+ int rate2_nocoeff = rd_stats->rate;
+ // Determine the motion mode. This will be one of SIMPLE_TRANSLATION,
+ // OBMC_CAUSAL or WARPED_CAUSAL
+ ret_val = motion_mode_rd(cpi, tile_data, x, bsize, rd_stats, rd_stats_y,
+ rd_stats_uv, args, ref_best_rd, skip_rd,
+ &rate_mv, &orig_dst, best_est_rd, do_tx_search,
+ inter_modes_info, 0);
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, motion_mode_rd_time);
+ end_timing(cpi, motion_mode_rd_time);
#endif
- assert(IMPLIES(!av1_check_newmv_joint_nonzero(cm, x),
- ret_val == INT64_MAX));
+ assert(
+ IMPLIES(!av1_check_newmv_joint_nonzero(cm, x), ret_val == INT64_MAX));
#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
- CHECK_FLEX_MV(
- check_mv_precision(cm, mbmi) == 0,
- " precision and MV mismatch at the end of the motion_mode_rd");
+ CHECK_FLEX_MV(
+ check_mv_precision(cm, mbmi) == 0,
+ " precision and MV mismatch at the end of the motion_mode_rd");
#endif
- if (ret_val != INT64_MAX) {
- int64_t tmp_rd = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
+ if (ret_val != INT64_MAX) {
+ int64_t tmp_rd = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
#if CONFIG_FLEX_MVRES
- if (tmp_rd < mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd) {
- // Only update mode_info if the new result is actually better.
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int =
- mbmi->mv[0].as_int;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].rate_mv = rate_mv;
+ if (is_pb_mv_precision_active(cm, mbmi, bsize) &&
+ tmp_rd < best_precision_rd_so_far) {
+ best_precision_so_far = mbmi->pb_mv_precision;
+ best_precision_rd_so_far = tmp_rd;
+ }
+ if (tmp_rd < mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd) {
+ // Only update mode_info if the new result is actually better.
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int =
+ mbmi->mv[0].as_int;
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].rate_mv = rate_mv;
#if CONFIG_DERIVED_MV
- if (mbmi->derived_mv_allowed && mbmi->use_derived_mv) {
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_mv =
- mbmi->derived_mv[0];
- }
-#endif // CONFIG_DERIVED_MV
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = tmp_rd;
+ if (mbmi->derived_mv_allowed && mbmi->use_derived_mv) {
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_mv =
+ mbmi->derived_mv[0];
}
+#endif // CONFIG_DERIVED_MV
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = tmp_rd;
+ }
#else
if (tmp_rd < mode_info[ref_mv_idx].rd) {
// Only update mode_info if the new result is actually better.
@@ -4494,177 +4101,119 @@
}
#endif
- // Collect mode stats for multiwinner mode processing
- store_winner_mode_stats(
- &cpi->common, x, mbmi, rd_stats, rd_stats_y, rd_stats_uv, refs,
- mbmi->mode, NULL, bsize, tmp_rd,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, do_tx_search);
- if (tmp_rd < best_rd) {
- // Update the best rd stats if we found the best mode so far
- best_rd_stats = *rd_stats;
- best_rd_stats_y = *rd_stats_y;
- best_rd_stats_uv = *rd_stats_uv;
- best_rd = tmp_rd;
- best_mbmi = *mbmi;
- best_xskip_txfm = txfm_info->skip_txfm;
- memcpy(best_blk_skip, txfm_info->blk_skip,
- sizeof(best_blk_skip[0]) * xd->height * xd->width);
- av1_copy_array(best_tx_type_map, xd->tx_type_map,
- xd->height * xd->width);
- motion_mode_cand->rate_mv = rate_mv;
- motion_mode_cand->rate2_nocoeff = rate2_nocoeff;
- }
-#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
- CHECK_FLEX_MV(
- check_mv_precision(cm, mbmi) == 0,
- " precision and MV mismatch at the end of the motion_mode_rd");
-#endif
-
- if (tmp_rd < ref_best_rd) {
- ref_best_rd = tmp_rd;
- best_ref_mv_idx = ref_mv_idx;
- }
+ // Collect mode stats for multiwinner mode processing
+ store_winner_mode_stats(
+ &cpi->common, x, mbmi, rd_stats, rd_stats_y, rd_stats_uv, refs,
+ mbmi->mode, NULL, bsize, tmp_rd,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type, do_tx_search);
+ if (tmp_rd < best_rd) {
+ // Update the best rd stats if we found the best mode so far
+ best_rd_stats = *rd_stats;
+ best_rd_stats_y = *rd_stats_y;
+ best_rd_stats_uv = *rd_stats_uv;
+ best_rd = tmp_rd;
+ best_mbmi = *mbmi;
+ best_xskip_txfm = txfm_info->skip_txfm;
+ memcpy(best_blk_skip, txfm_info->blk_skip,
+ sizeof(best_blk_skip[0]) * xd->height * xd->width);
+ av1_copy_array(best_tx_type_map, xd->tx_type_map,
+ xd->height * xd->width);
+ motion_mode_cand->rate_mv = rate_mv;
+ motion_mode_cand->rate2_nocoeff = rate2_nocoeff;
}
- restore_dst_buf(xd, orig_dst, num_planes);
-#if CONFIG_FLEX_MVRES
- }
+#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
+ CHECK_FLEX_MV(
+ check_mv_precision(cm, mbmi) == 0,
+ " precision and MV mismatch at the end of the motion_mode_rd");
#endif
+
+ if (tmp_rd < ref_best_rd) {
+ ref_best_rd = tmp_rd;
+ best_ref_mv_idx = ref_mv_idx;
+ }
+ }
+ restore_dst_buf(xd, orig_dst, num_planes);
+#if CONFIG_FLEX_MVRES
}
-
- if (best_rd == INT64_MAX) return INT64_MAX;
-
- // re-instate status of the best choice
- *rd_stats = best_rd_stats;
- *rd_stats_y = best_rd_stats_y;
- *rd_stats_uv = best_rd_stats_uv;
- *mbmi = best_mbmi;
- txfm_info->skip_txfm = best_xskip_txfm;
- assert(IMPLIES(mbmi->comp_group_idx == 1,
- mbmi->interinter_comp.type != COMPOUND_AVERAGE));
- memcpy(txfm_info->blk_skip, best_blk_skip,
- sizeof(best_blk_skip[0]) * xd->height * xd->width);
- av1_copy_array(xd->tx_type_map, best_tx_type_map, xd->height * xd->width);
-
- rd_stats->rdcost = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
- assert(av1_check_newmv_joint_nonzero(cm, x));
-
- return rd_stats->rdcost;
+#endif
}
+ if (best_rd == INT64_MAX) return INT64_MAX;
+
+ // re-instate status of the best choice
+ *rd_stats = best_rd_stats;
+ *rd_stats_y = best_rd_stats_y;
+ *rd_stats_uv = best_rd_stats_uv;
+ *mbmi = best_mbmi;
+ txfm_info->skip_txfm = best_xskip_txfm;
+ assert(IMPLIES(mbmi->comp_group_idx == 1,
+ mbmi->interinter_comp.type != COMPOUND_AVERAGE));
+ memcpy(txfm_info->blk_skip, best_blk_skip,
+ sizeof(best_blk_skip[0]) * xd->height * xd->width);
+ av1_copy_array(xd->tx_type_map, best_tx_type_map, xd->height * xd->width);
+
+ rd_stats->rdcost = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
+ assert(av1_check_newmv_joint_nonzero(cm, x));
+
+ return rd_stats->rdcost;
+}
+
#if CONFIG_BVP_IMPROVEMENT
- // Check if BV is valid
- static INLINE int is_bv_valid(const FULLPEL_MV *full_mv, const AV1_COMMON *cm,
- const MACROBLOCKD *xd, int mi_row, int mi_col,
- BLOCK_SIZE bsize,
- FULLPEL_MOTION_SEARCH_PARAMS fullms_params) {
- const MV dv = get_mv_from_fullmv(full_mv);
- if (!av1_is_fullmv_in_range(&fullms_params.mv_limits, *full_mv
+// Check if BV is valid
+static INLINE int is_bv_valid(const FULLPEL_MV *full_mv, const AV1_COMMON *cm,
+ const MACROBLOCKD *xd, int mi_row, int mi_col,
+ BLOCK_SIZE bsize,
+ FULLPEL_MOTION_SEARCH_PARAMS fullms_params) {
+ const MV dv = get_mv_from_fullmv(full_mv);
+ if (!av1_is_fullmv_in_range(&fullms_params.mv_limits, *full_mv
#if CONFIG_FLEX_MVRES
- ,
- MV_PRECISION_ONE_PEL
+ ,
+ MV_PRECISION_ONE_PEL
#endif
- ))
- return 0;
- if (!av1_is_dv_valid(dv, cm, xd, mi_row, mi_col, bsize,
- cm->seq_params.mib_size_log2))
- return 0;
- return 1;
- }
+ ))
+ return 0;
+ if (!av1_is_dv_valid(dv, cm, xd, mi_row, mi_col, bsize,
+ cm->seq_params.mib_size_log2))
+ return 0;
+ return 1;
+}
- // Search for the best ref BV
- int rd_pick_ref_bv(const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize,
- FULLPEL_MOTION_SEARCH_PARAMS fullms_params_init,
- int_mv *bv, int *cost) {
- const AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *mbmi = xd->mi[0];
- MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
- const TileInfo *tile = &xd->tile;
+// Search for the best ref BV
+int rd_pick_ref_bv(const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize,
+ FULLPEL_MOTION_SEARCH_PARAMS fullms_params_init, int_mv *bv,
+ int *cost) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *mbmi = xd->mi[0];
+ MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
+ const TileInfo *tile = &xd->tile;
- if (mbmi_ext->ref_mv_count[INTRA_FRAME] > 0) {
- int_mv best_bv;
- int best_intrabc_mode;
- int best_intrabc_drl_idx;
- int best_cost = INT_MAX;
+ if (mbmi_ext->ref_mv_count[INTRA_FRAME] > 0) {
+ int_mv best_bv;
+ int best_intrabc_mode;
+ int best_intrabc_drl_idx;
+ int best_cost = INT_MAX;
- int intrabc_drl_idx;
- int_mv cur_mv;
- int_mv cur_ref_bv;
- int cur_cost = INT_MAX;
- int cur_ref_bv_cost = 0;
+ int intrabc_drl_idx;
+ int_mv cur_mv;
+ int_mv cur_ref_bv;
+ int cur_cost = INT_MAX;
+ int cur_ref_bv_cost = 0;
- best_bv.as_int = 0;
- best_intrabc_drl_idx = 0;
- best_intrabc_mode = 0;
+ best_bv.as_int = 0;
+ best_intrabc_drl_idx = 0;
+ best_intrabc_mode = 0;
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
- FULLPEL_MOTION_SEARCH_PARAMS fullms_params = fullms_params_init;
+ FULLPEL_MOTION_SEARCH_PARAMS fullms_params = fullms_params_init;
- for (intrabc_drl_idx = 0;
- intrabc_drl_idx < mbmi_ext->ref_mv_count[INTRA_FRAME];
- intrabc_drl_idx++) {
- if (intrabc_drl_idx > MAX_REF_BV_STACK_SIZE - 1) break;
- cur_ref_bv = xd->ref_mv_stack[INTRA_FRAME][intrabc_drl_idx].this_mv;
-
- if (cur_ref_bv.as_int == 0 || cur_ref_bv.as_int == INVALID_MV) {
- cur_ref_bv.as_int = 0;
- }
- if (cur_ref_bv.as_int == 0) {
- av1_find_ref_dv(&cur_ref_bv, tile, cm->seq_params.mib_size, mi_row);
- }
- // Ref DV should not have sub-pel.
- assert((cur_ref_bv.as_mv.col & 7) == 0);
- assert((cur_ref_bv.as_mv.row & 7) == 0);
-
- mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = cur_ref_bv;
-
- fullms_params = fullms_params_init;
- av1_init_ref_mv(&fullms_params.mv_cost_params, &cur_ref_bv.as_mv);
- av1_set_mv_search_range(&fullms_params.mv_limits, &cur_ref_bv.as_mv
-#if CONFIG_FLEX_MVRES
- ,
- MV_PRECISION_ONE_PEL
-#endif
- );
- if (fullms_params.mv_limits.col_max < fullms_params.mv_limits.col_min ||
- fullms_params.mv_limits.row_max < fullms_params.mv_limits.row_min) {
- continue;
- }
-
- cur_ref_bv_cost =
- av1_get_ref_bv_rate_cost(1, intrabc_drl_idx, x, fullms_params,
- mbmi_ext->ref_mv_count[INTRA_FRAME]);
- cur_cost = av1_get_ref_mvpred_var_cost(cpi, xd, &fullms_params);
-
- if (cur_cost != INT_MAX) cur_cost += cur_ref_bv_cost;
- if (cur_cost < best_cost) {
- cur_mv.as_fullmv =
- get_fullmv_from_mv(fullms_params.mv_cost_params.ref_mv);
- if (is_bv_valid(&cur_mv.as_fullmv, cm, xd, mi_row, mi_col, bsize,
- fullms_params)) {
- best_bv.as_mv = get_mv_from_fullmv(&cur_mv.as_fullmv);
- best_cost = cur_cost;
- best_intrabc_mode = 1;
- best_intrabc_drl_idx = intrabc_drl_idx;
- }
- }
- }
-
- if (best_cost < INT_MAX) {
- bv->as_mv = best_bv.as_mv;
- mbmi->intrabc_drl_idx = best_intrabc_drl_idx;
- mbmi->intrabc_mode = best_intrabc_mode;
- } else {
- bv->as_int = 0;
- mbmi->intrabc_drl_idx = 0;
- mbmi->intrabc_mode = 0;
- }
-
- // set best ref_bv
- *cost = best_cost;
- cur_ref_bv = xd->ref_mv_stack[INTRA_FRAME][best_intrabc_drl_idx].this_mv;
+ for (intrabc_drl_idx = 0;
+ intrabc_drl_idx < mbmi_ext->ref_mv_count[INTRA_FRAME];
+ intrabc_drl_idx++) {
+ if (intrabc_drl_idx > MAX_REF_BV_STACK_SIZE - 1) break;
+ cur_ref_bv = xd->ref_mv_stack[INTRA_FRAME][intrabc_drl_idx].this_mv;
if (cur_ref_bv.as_int == 0 || cur_ref_bv.as_int == INVALID_MV) {
cur_ref_bv.as_int = 0;
@@ -4675,345 +4224,406 @@
// Ref DV should not have sub-pel.
assert((cur_ref_bv.as_mv.col & 7) == 0);
assert((cur_ref_bv.as_mv.row & 7) == 0);
+
mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = cur_ref_bv;
- return 1;
+
+ fullms_params = fullms_params_init;
+ av1_init_ref_mv(&fullms_params.mv_cost_params, &cur_ref_bv.as_mv);
+ av1_set_mv_search_range(&fullms_params.mv_limits, &cur_ref_bv.as_mv
+#if CONFIG_FLEX_MVRES
+ ,
+ MV_PRECISION_ONE_PEL
+#endif
+ );
+ if (fullms_params.mv_limits.col_max < fullms_params.mv_limits.col_min ||
+ fullms_params.mv_limits.row_max < fullms_params.mv_limits.row_min) {
+ continue;
+ }
+
+ cur_ref_bv_cost =
+ av1_get_ref_bv_rate_cost(1, intrabc_drl_idx, x, fullms_params,
+ mbmi_ext->ref_mv_count[INTRA_FRAME]);
+ cur_cost = av1_get_ref_mvpred_var_cost(cpi, xd, &fullms_params);
+
+ if (cur_cost != INT_MAX) cur_cost += cur_ref_bv_cost;
+ if (cur_cost < best_cost) {
+ cur_mv.as_fullmv =
+ get_fullmv_from_mv(fullms_params.mv_cost_params.ref_mv);
+ if (is_bv_valid(&cur_mv.as_fullmv, cm, xd, mi_row, mi_col, bsize,
+ fullms_params)) {
+ best_bv.as_mv = get_mv_from_fullmv(&cur_mv.as_fullmv);
+ best_cost = cur_cost;
+ best_intrabc_mode = 1;
+ best_intrabc_drl_idx = intrabc_drl_idx;
+ }
+ }
}
- return 0;
+
+ if (best_cost < INT_MAX) {
+ bv->as_mv = best_bv.as_mv;
+ mbmi->intrabc_drl_idx = best_intrabc_drl_idx;
+ mbmi->intrabc_mode = best_intrabc_mode;
+ } else {
+ bv->as_int = 0;
+ mbmi->intrabc_drl_idx = 0;
+ mbmi->intrabc_mode = 0;
+ }
+
+ // set best ref_bv
+ *cost = best_cost;
+ cur_ref_bv = xd->ref_mv_stack[INTRA_FRAME][best_intrabc_drl_idx].this_mv;
+
+ if (cur_ref_bv.as_int == 0 || cur_ref_bv.as_int == INVALID_MV) {
+ cur_ref_bv.as_int = 0;
+ }
+ if (cur_ref_bv.as_int == 0) {
+ av1_find_ref_dv(&cur_ref_bv, tile, cm->seq_params.mib_size, mi_row);
+ }
+ // Ref DV should not have sub-pel.
+ assert((cur_ref_bv.as_mv.col & 7) == 0);
+ assert((cur_ref_bv.as_mv.row & 7) == 0);
+ mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = cur_ref_bv;
+ return 1;
}
+ return 0;
+}
#endif // CONFIG_BVP_IMPROVEMENT
- /*!\brief Search for the best intrabc predictor
- *
- * \ingroup intra_mode_search
- * \callergraph
- * This function performs a motion search to find the best intrabc predictor.
- *
- * \returns Returns the best overall rdcost (including the non-intrabc modes
- * search before this function).
- */
- static int64_t rd_pick_intrabc_mode_sb(
- const AV1_COMP *cpi, MACROBLOCK *x, PICK_MODE_CONTEXT *ctx,
- RD_STATS *rd_stats, BLOCK_SIZE bsize, int64_t best_rd) {
- const AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- if (!av1_allow_intrabc(cm) || (xd->tree_type == CHROMA_PART) ||
- !cpi->oxcf.kf_cfg.enable_intrabc)
- return INT64_MAX;
- const int num_planes = av1_num_planes(cm);
- const TileInfo *tile = &xd->tile;
- MB_MODE_INFO *mbmi = xd->mi[0];
- TxfmSearchInfo *txfm_info = &x->txfm_search_info;
+/*!\brief Search for the best intrabc predictor
+ *
+ * \ingroup intra_mode_search
+ * \callergraph
+ * This function performs a motion search to find the best intrabc predictor.
+ *
+ * \returns Returns the best overall rdcost (including the non-intrabc modes
+ * search before this function).
+ */
+static int64_t rd_pick_intrabc_mode_sb(const AV1_COMP *cpi, MACROBLOCK *x,
+ PICK_MODE_CONTEXT *ctx,
+ RD_STATS *rd_stats, BLOCK_SIZE bsize,
+ int64_t best_rd) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ if (!av1_allow_intrabc(cm) || (xd->tree_type == CHROMA_PART) ||
+ !cpi->oxcf.kf_cfg.enable_intrabc)
+ return INT64_MAX;
+ const int num_planes = av1_num_planes(cm);
+ const TileInfo *tile = &xd->tile;
+ MB_MODE_INFO *mbmi = xd->mi[0];
+ TxfmSearchInfo *txfm_info = &x->txfm_search_info;
#if CONFIG_FLEX_MVRES
- set_default_max_mv_precision(mbmi, xd->sbi->sb_mv_precision);
- set_mv_precision(mbmi, MV_PRECISION_ONE_PEL);
+ set_default_max_mv_precision(mbmi, xd->sbi->sb_mv_precision);
+ set_mv_precision(mbmi, MV_PRECISION_ONE_PEL);
#if ADAPTIVE_PRECISION_SETS
- set_default_precision_set(cm, mbmi, bsize);
+ set_default_precision_set(cm, mbmi, bsize);
#endif
- set_most_probable_mv_precision(cm, mbmi, bsize);
+ set_most_probable_mv_precision(cm, mbmi, bsize);
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 1;
+#endif
#endif
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
- const int w = block_size_wide[bsize];
- const int h = block_size_high[bsize];
- const int sb_row = mi_row >> cm->seq_params.mib_size_log2;
- const int sb_col = mi_col >> cm->seq_params.mib_size_log2;
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
+ const int w = block_size_wide[bsize];
+ const int h = block_size_high[bsize];
+ const int sb_row = mi_row >> cm->seq_params.mib_size_log2;
+ const int sb_col = mi_col >> cm->seq_params.mib_size_log2;
- MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
- MV_REFERENCE_FRAME ref_frame = INTRA_FRAME;
+ MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
+ MV_REFERENCE_FRAME ref_frame = INTRA_FRAME;
#if CONFIG_IBC_SR_EXT
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 1;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 1;
#endif // CONFIG_IBC_SR_EXT
- av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
- xd->ref_mv_stack, xd->weight, NULL, mbmi_ext->global_mvs,
- mbmi_ext->mode_context);
+ av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
+ xd->ref_mv_stack, xd->weight, NULL, mbmi_ext->global_mvs,
+ mbmi_ext->mode_context);
#if CONFIG_IBC_SR_EXT
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
#endif // CONFIG_IBC_SR_EXT
- // TODO(Ravi): Populate mbmi_ext->ref_mv_stack[ref_frame][4] and
- // mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
- av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame);
+ // TODO(Ravi): Populate mbmi_ext->ref_mv_stack[ref_frame][4] and
+ // mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
+ av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame);
#if CONFIG_FLEX_MVRES
- int_mv dv_ref = av1_find_best_ref_mv_from_stack(mbmi_ext, ref_frame,
- mbmi->pb_mv_precision);
+ int_mv dv_ref = av1_find_best_ref_mv_from_stack(mbmi_ext, ref_frame,
+ mbmi->pb_mv_precision);
#else
int_mv dv_ref = av1_find_best_ref_mv_from_stack(
/*allow_hp=*/0, mbmi_ext, ref_frame, /*is_integer=*/0);
#endif
- dv_ref.as_int = dv_ref.as_int == INVALID_MV ? 0 : dv_ref.as_int;
+ dv_ref.as_int = dv_ref.as_int == INVALID_MV ? 0 : dv_ref.as_int;
#if CONFIG_BVP_IMPROVEMENT
- if (mbmi_ext->ref_mv_count[INTRA_FRAME] == 0) {
- dv_ref.as_int = 0;
- }
+ if (mbmi_ext->ref_mv_count[INTRA_FRAME] == 0) {
+ dv_ref.as_int = 0;
+ }
#endif // CONFIG_BVP_IMPROVEMENT
- if (dv_ref.as_int == 0) {
- av1_find_ref_dv(&dv_ref, tile, cm->seq_params.mib_size, mi_row);
- }
- // Ref DV should not have sub-pel.
- assert((dv_ref.as_mv.col & 7) == 0);
- assert((dv_ref.as_mv.row & 7) == 0);
- mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = dv_ref;
+ if (dv_ref.as_int == 0) {
+ av1_find_ref_dv(&dv_ref, tile, cm->seq_params.mib_size, mi_row);
+ }
+ // Ref DV should not have sub-pel.
+ assert((dv_ref.as_mv.col & 7) == 0);
+ assert((dv_ref.as_mv.row & 7) == 0);
+ mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = dv_ref;
- struct buf_2d yv12_mb[MAX_MB_PLANE];
- av1_setup_pred_block(xd, yv12_mb, xd->cur_buf, NULL, NULL, num_planes);
- for (int i = 0; i < num_planes; ++i) {
- xd->plane[i].pre[0] = yv12_mb[i];
- }
+ struct buf_2d yv12_mb[MAX_MB_PLANE];
+ av1_setup_pred_block(xd, yv12_mb, xd->cur_buf, NULL, NULL, num_planes);
+ for (int i = 0; i < num_planes; ++i) {
+ xd->plane[i].pre[0] = yv12_mb[i];
+ }
- enum IntrabcMotionDirection {
- IBC_MOTION_ABOVE,
- IBC_MOTION_LEFT,
- IBC_MOTION_DIRECTIONS
- };
+ enum IntrabcMotionDirection {
+ IBC_MOTION_ABOVE,
+ IBC_MOTION_LEFT,
+ IBC_MOTION_DIRECTIONS
+ };
- MB_MODE_INFO best_mbmi = *mbmi;
- RD_STATS best_rdstats = *rd_stats;
- uint8_t best_blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE] = { 0 };
- TX_TYPE best_tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
- av1_copy_array(best_tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
+ MB_MODE_INFO best_mbmi = *mbmi;
+ RD_STATS best_rdstats = *rd_stats;
+ uint8_t best_blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE] = { 0 };
+ TX_TYPE best_tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
+ av1_copy_array(best_tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
- FULLPEL_MOTION_SEARCH_PARAMS fullms_params;
- const search_site_config *lookahead_search_sites =
- cpi->mv_search_params.search_site_cfg[SS_CFG_LOOKAHEAD];
- // TODO(chiyotsai@google.com): Change the resolution here to MV_SUBPEL_NONE
- // in a separate commit.
+ FULLPEL_MOTION_SEARCH_PARAMS fullms_params;
+ const search_site_config *lookahead_search_sites =
+ cpi->mv_search_params.search_site_cfg[SS_CFG_LOOKAHEAD];
+ // TODO(chiyotsai@google.com): Change the resolution here to MV_SUBPEL_NONE
+ // in a separate commit.
#if CONFIG_FLEX_MVRES
- av1_make_default_fullpel_ms_params(&fullms_params, cpi, x, bsize,
- &dv_ref.as_mv, mbmi->max_mv_precision,
- lookahead_search_sites,
- /*fine_search_interval=*/0);
+ av1_make_default_fullpel_ms_params(&fullms_params, cpi, x, bsize,
+ &dv_ref.as_mv, mbmi->max_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
+ lookahead_search_sites,
+ /*fine_search_interval=*/0);
#else
av1_make_default_fullpel_ms_params(&fullms_params, cpi, x, bsize,
&dv_ref.as_mv, lookahead_search_sites,
/*fine_search_interval=*/0);
#endif
#if CONFIG_BVCOST_UPDATE && !CONFIG_FLEX_MVRES
- // The costs for block vector are stored in cpi->dv_costs. Assign the costs
- // to mv_cost_params for motion search.
- fullms_params.mv_cost_params.mvjcost = cpi->dv_costs.joint_mv;
- fullms_params.mv_cost_params.mvcost[0] =
- (int *)&cpi->dv_costs.mv_component[0][MV_MAX];
- fullms_params.mv_cost_params.mvcost[1] =
- (int *)&cpi->dv_costs.mv_component[1][MV_MAX];
+ // The costs for block vector are stored in cpi->dv_costs. Assign the costs
+ // to mv_cost_params for motion search.
+ fullms_params.mv_cost_params.mvjcost = cpi->dv_costs.joint_mv;
+ fullms_params.mv_cost_params.mvcost[0] =
+ (int *)&cpi->dv_costs.mv_component[0][MV_MAX];
+ fullms_params.mv_cost_params.mvcost[1] =
+ (int *)&cpi->dv_costs.mv_component[1][MV_MAX];
#endif // CONFIG_BVCOST_UPDATE
- fullms_params.is_intra_mode = 1;
+ fullms_params.is_intra_mode = 1;
#if CONFIG_IBC_SR_EXT
- fullms_params.xd = xd;
- fullms_params.cm = cm;
- fullms_params.mib_size_log2 = cm->seq_params.mib_size_log2;
- fullms_params.mi_col = mi_col;
- fullms_params.mi_row = mi_row;
+ fullms_params.xd = xd;
+ fullms_params.cm = cm;
+ fullms_params.mib_size_log2 = cm->seq_params.mib_size_log2;
+ fullms_params.mi_col = mi_col;
+ fullms_params.mi_row = mi_row;
#endif // CONFIG_IBC_SR_EXT
#if CONFIG_BVP_IMPROVEMENT
- fullms_params.x = x;
- fullms_params.cm = cm;
- fullms_params.ref_bv_cnt = mbmi_ext->ref_mv_count[INTRA_FRAME];
- mbmi->intrabc_mode = 0;
- mbmi->intrabc_drl_idx = 0;
- mbmi->ref_bv.as_int = 0;
+ fullms_params.x = x;
+ fullms_params.cm = cm;
+ fullms_params.ref_bv_cnt = mbmi_ext->ref_mv_count[INTRA_FRAME];
+ mbmi->intrabc_mode = 0;
+ mbmi->intrabc_drl_idx = 0;
+ mbmi->ref_bv.as_int = 0;
#endif // CONFIG_BVP_IMPROVEMENT
- for (enum IntrabcMotionDirection dir = IBC_MOTION_ABOVE;
- dir < IBC_MOTION_DIRECTIONS; ++dir) {
+ for (enum IntrabcMotionDirection dir = IBC_MOTION_ABOVE;
+ dir < IBC_MOTION_DIRECTIONS; ++dir) {
#if CONFIG_IBC_SR_EXT
- if (frame_is_intra_only(cm) && cm->features.allow_global_intrabc) {
+ if (frame_is_intra_only(cm) && cm->features.allow_global_intrabc) {
#endif // CONFIG_IBC_SR_EXT
- switch (dir) {
- case IBC_MOTION_ABOVE:
- fullms_params.mv_limits.col_min =
- (tile->mi_col_start - mi_col) * MI_SIZE;
- fullms_params.mv_limits.col_max =
- (tile->mi_col_end - mi_col) * MI_SIZE - w;
- fullms_params.mv_limits.row_min =
- (tile->mi_row_start - mi_row) * MI_SIZE;
+ switch (dir) {
+ case IBC_MOTION_ABOVE:
+ fullms_params.mv_limits.col_min =
+ (tile->mi_col_start - mi_col) * MI_SIZE;
+ fullms_params.mv_limits.col_max =
+ (tile->mi_col_end - mi_col) * MI_SIZE - w;
+ fullms_params.mv_limits.row_min =
+ (tile->mi_row_start - mi_row) * MI_SIZE;
#if CONFIG_IBC_SR_EXT
- fullms_params.mv_limits.row_max = -h;
+ fullms_params.mv_limits.row_max = -h;
#else
fullms_params.mv_limits.row_max =
(sb_row * cm->seq_params.mib_size - mi_row) * MI_SIZE - h;
#endif // CONFIG_IBC_SR_EXT
- break;
- case IBC_MOTION_LEFT:
- fullms_params.mv_limits.col_min =
- (tile->mi_col_start - mi_col) * MI_SIZE;
+ break;
+ case IBC_MOTION_LEFT:
+ fullms_params.mv_limits.col_min =
+ (tile->mi_col_start - mi_col) * MI_SIZE;
#if CONFIG_IBC_SR_EXT
- fullms_params.mv_limits.col_max = -w;
+ fullms_params.mv_limits.col_max = -w;
#else
fullms_params.mv_limits.col_max =
(sb_col * cm->seq_params.mib_size - mi_col) * MI_SIZE - w;
#endif // CONFIG_IBC_SR_EXT
// TODO(aconverse@google.com): Minimize the overlap between above and
// left areas.
- fullms_params.mv_limits.row_min =
- (tile->mi_row_start - mi_row) * MI_SIZE;
- int bottom_coded_mi_edge = AOMMIN(
- (sb_row + 1) * cm->seq_params.mib_size, tile->mi_row_end);
- fullms_params.mv_limits.row_max =
- (bottom_coded_mi_edge - mi_row) * MI_SIZE - h;
- break;
- default: assert(0);
- }
-#if CONFIG_IBC_SR_EXT
- } else {
- int left_coded_mi_edge =
- AOMMAX((sb_col - 1) * cm->seq_params.mib_size, tile->mi_col_start);
- int right_coded_mi_edge =
- AOMMIN((sb_col + 1) * cm->seq_params.mib_size, tile->mi_col_end);
- int up_coded_mi_edge =
- AOMMAX((sb_row)*cm->seq_params.mib_size, tile->mi_row_start);
- int bottom_coded_mi_edge =
- AOMMIN((sb_row + 1) * cm->seq_params.mib_size, tile->mi_row_end);
-
- switch (dir) {
- case IBC_MOTION_ABOVE:
- fullms_params.mv_limits.col_min =
- (left_coded_mi_edge - mi_col) * MI_SIZE;
- fullms_params.mv_limits.col_max =
- (right_coded_mi_edge - mi_col) * MI_SIZE - w;
- fullms_params.mv_limits.row_min =
- (up_coded_mi_edge - mi_row) * MI_SIZE;
- fullms_params.mv_limits.row_max = -h;
- break;
- case IBC_MOTION_LEFT:
- fullms_params.mv_limits.col_min =
- (left_coded_mi_edge - mi_col) * MI_SIZE;
- fullms_params.mv_limits.col_max = -w;
- fullms_params.mv_limits.row_min =
- (up_coded_mi_edge - mi_row) * MI_SIZE;
- fullms_params.mv_limits.row_max =
- (bottom_coded_mi_edge - mi_row) * MI_SIZE - h;
- break;
- default: assert(0);
- }
+ fullms_params.mv_limits.row_min =
+ (tile->mi_row_start - mi_row) * MI_SIZE;
+ int bottom_coded_mi_edge =
+ AOMMIN((sb_row + 1) * cm->seq_params.mib_size, tile->mi_row_end);
+ fullms_params.mv_limits.row_max =
+ (bottom_coded_mi_edge - mi_row) * MI_SIZE - h;
+ break;
+ default: assert(0);
}
+#if CONFIG_IBC_SR_EXT
+ } else {
+ int left_coded_mi_edge =
+ AOMMAX((sb_col - 1) * cm->seq_params.mib_size, tile->mi_col_start);
+ int right_coded_mi_edge =
+ AOMMIN((sb_col + 1) * cm->seq_params.mib_size, tile->mi_col_end);
+ int up_coded_mi_edge =
+ AOMMAX((sb_row)*cm->seq_params.mib_size, tile->mi_row_start);
+ int bottom_coded_mi_edge =
+ AOMMIN((sb_row + 1) * cm->seq_params.mib_size, tile->mi_row_end);
+
+ switch (dir) {
+ case IBC_MOTION_ABOVE:
+ fullms_params.mv_limits.col_min =
+ (left_coded_mi_edge - mi_col) * MI_SIZE;
+ fullms_params.mv_limits.col_max =
+ (right_coded_mi_edge - mi_col) * MI_SIZE - w;
+ fullms_params.mv_limits.row_min =
+ (up_coded_mi_edge - mi_row) * MI_SIZE;
+ fullms_params.mv_limits.row_max = -h;
+ break;
+ case IBC_MOTION_LEFT:
+ fullms_params.mv_limits.col_min =
+ (left_coded_mi_edge - mi_col) * MI_SIZE;
+ fullms_params.mv_limits.col_max = -w;
+ fullms_params.mv_limits.row_min =
+ (up_coded_mi_edge - mi_row) * MI_SIZE;
+ fullms_params.mv_limits.row_max =
+ (bottom_coded_mi_edge - mi_row) * MI_SIZE - h;
+ break;
+ default: assert(0);
+ }
+ }
#endif // CONFIG_IBC_SR_EXT
- assert(fullms_params.mv_limits.col_min >=
- fullms_params.mv_limits.col_min);
- assert(fullms_params.mv_limits.col_max <=
- fullms_params.mv_limits.col_max);
- assert(fullms_params.mv_limits.row_min >=
- fullms_params.mv_limits.row_min);
- assert(fullms_params.mv_limits.row_max <=
- fullms_params.mv_limits.row_max);
+ assert(fullms_params.mv_limits.col_min >= fullms_params.mv_limits.col_min);
+ assert(fullms_params.mv_limits.col_max <= fullms_params.mv_limits.col_max);
+ assert(fullms_params.mv_limits.row_min >= fullms_params.mv_limits.row_min);
+ assert(fullms_params.mv_limits.row_max <= fullms_params.mv_limits.row_max);
#if CONFIG_BVP_IMPROVEMENT
- FULLPEL_MOTION_SEARCH_PARAMS fullms_params_init = fullms_params;
- int best_ref_bv_cost = INT_MAX;
- int_mv best_bv;
- int_mv best_ref_bv;
- best_bv.as_int = 0;
- best_ref_bv.as_int = dv_ref.as_int;
- if (rd_pick_ref_bv(cpi, x, bsize, fullms_params_init, &best_bv,
- &best_ref_bv_cost)) {
- fullms_params = fullms_params_init;
- best_ref_bv = mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv;
- av1_init_ref_mv(&fullms_params.mv_cost_params, &best_ref_bv.as_mv);
- av1_set_mv_search_range(&fullms_params.mv_limits, &best_ref_bv.as_mv
-#if CONFIG_FLEX_MVRES
- ,
- MV_PRECISION_ONE_PEL
-#endif
-
- );
- dv_ref.as_mv = best_ref_bv.as_mv;
- }
- mbmi->ref_bv = dv_ref;
- int best_intrabc_drl_idx = mbmi->intrabc_drl_idx;
- int best_intrabc_mode = mbmi->intrabc_mode;
-#endif // CONFIG_BVP_IMPROVEMENT
-
- av1_set_mv_search_range(&fullms_params.mv_limits, &dv_ref.as_mv
-
+ FULLPEL_MOTION_SEARCH_PARAMS fullms_params_init = fullms_params;
+ int best_ref_bv_cost = INT_MAX;
+ int_mv best_bv;
+ int_mv best_ref_bv;
+ best_bv.as_int = 0;
+ best_ref_bv.as_int = dv_ref.as_int;
+ if (rd_pick_ref_bv(cpi, x, bsize, fullms_params_init, &best_bv,
+ &best_ref_bv_cost)) {
+ fullms_params = fullms_params_init;
+ best_ref_bv = mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv;
+ av1_init_ref_mv(&fullms_params.mv_cost_params, &best_ref_bv.as_mv);
+ av1_set_mv_search_range(&fullms_params.mv_limits, &best_ref_bv.as_mv
#if CONFIG_FLEX_MVRES
,
- mbmi->max_mv_precision
+ MV_PRECISION_ONE_PEL
#endif
+
);
-
- if (fullms_params.mv_limits.col_max < fullms_params.mv_limits.col_min ||
- fullms_params.mv_limits.row_max < fullms_params.mv_limits.row_min) {
- continue;
- }
-
- const int step_param = cpi->mv_search_params.mv_step_param;
- const FULLPEL_MV start_mv = get_fullmv_from_mv(&dv_ref.as_mv);
- IntraBCHashInfo *intrabc_hash_info = &x->intrabc_hash_info;
- int_mv best_mv, best_hash_mv;
-
- int bestsme = av1_full_pixel_search(start_mv, &fullms_params, step_param,
- NULL, &best_mv.as_fullmv, NULL);
-#if CONFIG_BVP_IMPROVEMENT
- if (bestsme != INT_MAX && is_bv_valid(&best_mv.as_fullmv, cm, xd, mi_row,
- mi_col, bsize, fullms_params)) {
- int cur_ref_bv_cost = bestsme;
- int cur_intrabc_mode = 0;
- int cur_intrabc_drl_idx = 0;
- int_mv cur_ref_bv;
- cur_ref_bv.as_mv = dv_ref.as_mv;
- int_mv cur_bv;
- cur_bv.as_mv = get_mv_from_fullmv(&best_mv.as_fullmv);
- int cur_dist =
- bestsme -
- av1_get_mv_err_cost(&cur_bv.as_mv, &fullms_params.mv_cost_params);
- assert(cur_dist >= 0);
- int cur_rate = av1_pick_ref_bv(&best_mv.as_fullmv, &fullms_params);
-
- if (cur_rate != INT_MAX) {
- cur_ref_bv_cost = cur_dist + cur_rate;
- cur_intrabc_mode = mbmi->intrabc_mode;
- assert(cur_intrabc_mode == 0);
- cur_intrabc_drl_idx = mbmi->intrabc_drl_idx;
- cur_ref_bv = mbmi->ref_bv;
- }
-
- if (cur_ref_bv_cost < best_ref_bv_cost) {
- best_ref_bv_cost = cur_ref_bv_cost;
- best_intrabc_mode = cur_intrabc_mode;
- best_intrabc_drl_idx = cur_intrabc_drl_idx;
- best_ref_bv = cur_ref_bv;
- best_bv.as_mv = cur_bv.as_mv;
- }
- }
+ dv_ref.as_mv = best_ref_bv.as_mv;
+ }
+ mbmi->ref_bv = dv_ref;
+ int best_intrabc_drl_idx = mbmi->intrabc_drl_idx;
+ int best_intrabc_mode = mbmi->intrabc_mode;
#endif // CONFIG_BVP_IMPROVEMENT
- const int hashsme = av1_intrabc_hash_search(
- cpi, xd, &fullms_params, intrabc_hash_info, &best_hash_mv.as_fullmv);
+ av1_set_mv_search_range(&fullms_params.mv_limits, &dv_ref.as_mv
+#if CONFIG_FLEX_MVRES
+ ,
+ mbmi->max_mv_precision
+#endif
+ );
+
+ if (fullms_params.mv_limits.col_max < fullms_params.mv_limits.col_min ||
+ fullms_params.mv_limits.row_max < fullms_params.mv_limits.row_min) {
+ continue;
+ }
+
+ const int step_param = cpi->mv_search_params.mv_step_param;
+ const FULLPEL_MV start_mv = get_fullmv_from_mv(&dv_ref.as_mv);
+ IntraBCHashInfo *intrabc_hash_info = &x->intrabc_hash_info;
+ int_mv best_mv, best_hash_mv;
+
+ int bestsme = av1_full_pixel_search(start_mv, &fullms_params, step_param,
+ NULL, &best_mv.as_fullmv, NULL);
#if CONFIG_BVP_IMPROVEMENT
- if (hashsme != INT_MAX &&
- is_bv_valid(&best_hash_mv.as_fullmv, cm, xd, mi_row, mi_col, bsize,
- fullms_params)) {
- int cur_ref_bv_cost = hashsme;
+ if (bestsme != INT_MAX && is_bv_valid(&best_mv.as_fullmv, cm, xd, mi_row,
+ mi_col, bsize, fullms_params)) {
+ int cur_ref_bv_cost = bestsme;
+ int cur_intrabc_mode = 0;
+ int cur_intrabc_drl_idx = 0;
+ int_mv cur_ref_bv;
+ cur_ref_bv.as_mv = dv_ref.as_mv;
+ int_mv cur_bv;
+ cur_bv.as_mv = get_mv_from_fullmv(&best_mv.as_fullmv);
+ int cur_dist =
+ bestsme -
+ av1_get_mv_err_cost(&cur_bv.as_mv, &fullms_params.mv_cost_params);
+ assert(cur_dist >= 0);
+ int cur_rate = av1_pick_ref_bv(&best_mv.as_fullmv, &fullms_params);
- int cur_intrabc_mode = mbmi->intrabc_mode;
- int cur_intrabc_drl_idx = mbmi->intrabc_drl_idx;
-
- int_mv cur_ref_bv;
- cur_ref_bv.as_mv = mbmi->ref_bv.as_mv;
-
- int_mv cur_bv;
- cur_bv.as_mv = get_mv_from_fullmv(&best_hash_mv.as_fullmv);
-
- if (cur_ref_bv_cost < best_ref_bv_cost) {
- best_ref_bv_cost = cur_ref_bv_cost;
- best_intrabc_mode = cur_intrabc_mode;
- best_intrabc_drl_idx = cur_intrabc_drl_idx;
- best_ref_bv = cur_ref_bv;
- best_bv.as_mv = cur_bv.as_mv;
- }
+ if (cur_rate != INT_MAX) {
+ cur_ref_bv_cost = cur_dist + cur_rate;
+ cur_intrabc_mode = mbmi->intrabc_mode;
+ assert(cur_intrabc_mode == 0);
+ cur_intrabc_drl_idx = mbmi->intrabc_drl_idx;
+ cur_ref_bv = mbmi->ref_bv;
}
- if (best_ref_bv_cost == INT_MAX) continue;
+ if (cur_ref_bv_cost < best_ref_bv_cost) {
+ best_ref_bv_cost = cur_ref_bv_cost;
+ best_intrabc_mode = cur_intrabc_mode;
+ best_intrabc_drl_idx = cur_intrabc_drl_idx;
+ best_ref_bv = cur_ref_bv;
+ best_bv.as_mv = cur_bv.as_mv;
+ }
+ }
+#endif // CONFIG_BVP_IMPROVEMENT
- mbmi->intrabc_mode = best_intrabc_mode;
- mbmi->intrabc_drl_idx = best_intrabc_drl_idx;
- mbmi->ref_bv = best_ref_bv;
+ const int hashsme = av1_intrabc_hash_search(
+ cpi, xd, &fullms_params, intrabc_hash_info, &best_hash_mv.as_fullmv);
- MV dv = best_bv.as_mv;
- dv_ref.as_mv = best_ref_bv.as_mv;
+#if CONFIG_BVP_IMPROVEMENT
+ if (hashsme != INT_MAX &&
+ is_bv_valid(&best_hash_mv.as_fullmv, cm, xd, mi_row, mi_col, bsize,
+ fullms_params)) {
+ int cur_ref_bv_cost = hashsme;
+
+ int cur_intrabc_mode = mbmi->intrabc_mode;
+ int cur_intrabc_drl_idx = mbmi->intrabc_drl_idx;
+
+ int_mv cur_ref_bv;
+ cur_ref_bv.as_mv = mbmi->ref_bv.as_mv;
+
+ int_mv cur_bv;
+ cur_bv.as_mv = get_mv_from_fullmv(&best_hash_mv.as_fullmv);
+
+ if (cur_ref_bv_cost < best_ref_bv_cost) {
+ best_ref_bv_cost = cur_ref_bv_cost;
+ best_intrabc_mode = cur_intrabc_mode;
+ best_intrabc_drl_idx = cur_intrabc_drl_idx;
+ best_ref_bv = cur_ref_bv;
+ best_bv.as_mv = cur_bv.as_mv;
+ }
+ }
+
+ if (best_ref_bv_cost == INT_MAX) continue;
+
+ mbmi->intrabc_mode = best_intrabc_mode;
+ mbmi->intrabc_drl_idx = best_intrabc_drl_idx;
+ mbmi->ref_bv = best_ref_bv;
+
+ MV dv = best_bv.as_mv;
+ dv_ref.as_mv = best_ref_bv.as_mv;
#else
if (hashsme < bestsme) {
best_mv = best_hash_mv;
@@ -5035,38 +4645,38 @@
continue;
#endif // CONFIG_BVP_IMPROVEMENT
- // DV should not have sub-pel.
- assert((dv.col & 7) == 0);
- assert((dv.row & 7) == 0);
- memset(&mbmi->palette_mode_info, 0, sizeof(mbmi->palette_mode_info));
- mbmi->filter_intra_mode_info.use_filter_intra = 0;
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 1;
- assert(xd->tree_type != CHROMA_PART);
+ // DV should not have sub-pel.
+ assert((dv.col & 7) == 0);
+ assert((dv.row & 7) == 0);
+ memset(&mbmi->palette_mode_info, 0, sizeof(mbmi->palette_mode_info));
+ mbmi->filter_intra_mode_info.use_filter_intra = 0;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 1;
+ assert(xd->tree_type != CHROMA_PART);
#if CONFIG_ORIP
- mbmi->angle_delta[PLANE_TYPE_Y] = 0;
- mbmi->angle_delta[PLANE_TYPE_UV] = 0;
+ mbmi->angle_delta[PLANE_TYPE_Y] = 0;
+ mbmi->angle_delta[PLANE_TYPE_UV] = 0;
#endif
#if CONFIG_FORWARDSKIP
- mbmi->fsc_mode[PLANE_TYPE_Y] = 0;
- mbmi->fsc_mode[PLANE_TYPE_UV] = 0;
+ mbmi->fsc_mode[PLANE_TYPE_Y] = 0;
+ mbmi->fsc_mode[PLANE_TYPE_UV] = 0;
#endif // CONFIG_FORWARDSKIP
- mbmi->mode = DC_PRED;
- mbmi->uv_mode = UV_DC_PRED;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->mv[0].as_mv = dv;
- mbmi->interp_fltr = BILINEAR;
- mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 0;
+ mbmi->mode = DC_PRED;
+ mbmi->uv_mode = UV_DC_PRED;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->mv[0].as_mv = dv;
+ mbmi->interp_fltr = BILINEAR;
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 0;
#if CONFIG_DERIVED_MV
- mbmi->derived_mv_allowed = mbmi->use_derived_mv = 0;
+ mbmi->derived_mv_allowed = mbmi->use_derived_mv = 0;
#endif // CONFIG_DERIVED_MV
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
- av1_num_planes(cm) - 1);
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
+ av1_num_planes(cm) - 1);
#if CONFIG_FLEX_MVRES
- const IntraBCMvCosts *const dv_costs = &cpi->dv_costs;
+ const IntraBCMvCosts *const dv_costs = &cpi->dv_costs;
#else
const IntraBCMVCosts *const dv_costs = &cpi->dv_costs;
int *dvcost[2] = { (int *)&dv_costs->mv_component[0][MV_MAX],
@@ -5074,20 +4684,20 @@
#endif
#if CONFIG_BVP_IMPROVEMENT
- int rate_mv = 0;
- if (!mbmi->intrabc_mode)
+ int rate_mv = 0;
+ if (!mbmi->intrabc_mode)
#if CONFIG_FLEX_MVRES
- rate_mv += av1_intrabc_mv_bit_cost(&dv, &dv_ref.as_mv, dv_costs,
- MV_COST_WEIGHT_SUB);
+ rate_mv += av1_intrabc_mv_bit_cost(&dv, &dv_ref.as_mv, dv_costs,
+ MV_COST_WEIGHT_SUB);
#else
rate_mv += av1_mv_bit_cost(&dv, &dv_ref.as_mv, dv_costs->joint_mv, dvcost,
MV_COST_WEIGHT_SUB);
#endif
- int rate_mode = x->mode_costs.intrabc_cost[1];
- rate_mode += x->mode_costs.intrabc_mode_cost[mbmi->intrabc_mode];
- rate_mode += av1_get_intrabc_drl_idx_cost(MAX_REF_BV_STACK_SIZE,
- mbmi->intrabc_drl_idx, x);
+ int rate_mode = x->mode_costs.intrabc_cost[1];
+ rate_mode += x->mode_costs.intrabc_mode_cost[mbmi->intrabc_mode];
+ rate_mode += av1_get_intrabc_drl_idx_cost(MAX_REF_BV_STACK_SIZE,
+ mbmi->intrabc_drl_idx, x);
#else
// TODO(aconverse@google.com): The full motion field defining discount
// in MV_COST_WEIGHT is too large. Explore other values.
@@ -5103,160 +4713,156 @@
const int rate_mode = x->mode_costs.intrabc_cost[1];
#endif // CONFIG_BVP_IMPROVEMENT
- RD_STATS rd_stats_yuv, rd_stats_y, rd_stats_uv;
- if (!av1_txfm_search(cpi, x, bsize, &rd_stats_yuv, &rd_stats_y,
- &rd_stats_uv, rate_mode + rate_mv, INT64_MAX))
- continue;
- rd_stats_yuv.rdcost =
- RDCOST(x->rdmult, rd_stats_yuv.rate, rd_stats_yuv.dist);
- if (rd_stats_yuv.rdcost < best_rd) {
- best_rd = rd_stats_yuv.rdcost;
- best_mbmi = *mbmi;
- best_rdstats = rd_stats_yuv;
- memcpy(best_blk_skip, txfm_info->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * xd->height * xd->width);
- av1_copy_array(best_tx_type_map, xd->tx_type_map,
- xd->height * xd->width);
- }
+ RD_STATS rd_stats_yuv, rd_stats_y, rd_stats_uv;
+ if (!av1_txfm_search(cpi, x, bsize, &rd_stats_yuv, &rd_stats_y,
+ &rd_stats_uv, rate_mode + rate_mv, INT64_MAX))
+ continue;
+ rd_stats_yuv.rdcost =
+ RDCOST(x->rdmult, rd_stats_yuv.rate, rd_stats_yuv.dist);
+ if (rd_stats_yuv.rdcost < best_rd) {
+ best_rd = rd_stats_yuv.rdcost;
+ best_mbmi = *mbmi;
+ best_rdstats = rd_stats_yuv;
+ memcpy(best_blk_skip, txfm_info->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * xd->height * xd->width);
+ av1_copy_array(best_tx_type_map, xd->tx_type_map, xd->height * xd->width);
}
- *mbmi = best_mbmi;
+ }
+ *mbmi = best_mbmi;
#if CONFIG_BVP_IMPROVEMENT
- if (mbmi->use_intrabc[xd->tree_type == CHROMA_PART]) {
- mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = mbmi->ref_bv;
- } else {
- mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv.as_int = 0;
- }
+ if (mbmi->use_intrabc[xd->tree_type == CHROMA_PART]) {
+ mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = mbmi->ref_bv;
+ } else {
+ mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv.as_int = 0;
+ }
#endif // CONFIG_BVP_IMPROVEMENT
- *rd_stats = best_rdstats;
- memcpy(txfm_info->blk_skip, best_blk_skip,
- sizeof(txfm_info->blk_skip[0]) * xd->height * xd->width);
- av1_copy_array(xd->tx_type_map, best_tx_type_map, ctx->num_4x4_blk);
+ *rd_stats = best_rdstats;
+ memcpy(txfm_info->blk_skip, best_blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * xd->height * xd->width);
+ av1_copy_array(xd->tx_type_map, best_tx_type_map, ctx->num_4x4_blk);
#if CONFIG_RD_DEBUG
- mbmi->rd_stats = *rd_stats;
+ mbmi->rd_stats = *rd_stats;
#endif
- assert(av1_check_newmv_joint_nonzero(cm, x));
- return best_rd;
+ assert(av1_check_newmv_joint_nonzero(cm, x));
+ return best_rd;
+}
+
+// TODO(chiyotsai@google.com): We are using struct $struct_name instead of
+// their typedef here because Doxygen doesn't know about the typedefs yet. So
+// using the typedef will prevent doxygen from finding this function and
+// generating the callgraph. Once documents for AV1_COMP and MACROBLOCK are
+// added to doxygen, we can revert back to using the typedefs.
+void av1_rd_pick_intra_mode_sb(const struct AV1_COMP *cpi, struct macroblock *x,
+ struct RD_STATS *rd_cost, BLOCK_SIZE bsize,
+ PICK_MODE_CONTEXT *ctx, int64_t best_rd) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ const int num_planes = av1_num_planes(cm);
+ TxfmSearchInfo *txfm_info = &x->txfm_search_info;
+ int rate_y = 0, rate_uv = 0, rate_y_tokenonly = 0, rate_uv_tokenonly = 0;
+ int y_skip_txfm = 0, uv_skip_txfm = 0;
+ int64_t dist_y = 0, dist_uv = 0;
+
+ ctx->rd_stats.skip_txfm = 0;
+ mbmi->ref_frame[0] = INTRA_FRAME;
+ mbmi->ref_frame[1] = NONE_FRAME;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
+ if (xd->tree_type != CHROMA_PART) {
+ mbmi->mv[0].as_int = 0;
+ mbmi->skip_mode = 0;
}
+ const int64_t intra_yrd =
+ (xd->tree_type == CHROMA_PART)
+ ? 0
+ : av1_rd_pick_intra_sby_mode(cpi, x, &rate_y, &rate_y_tokenonly,
+ &dist_y, &y_skip_txfm, bsize, best_rd,
+ ctx);
- // TODO(chiyotsai@google.com): We are using struct $struct_name instead of
- // their typedef here because Doxygen doesn't know about the typedefs yet. So
- // using the typedef will prevent doxygen from finding this function and
- // generating the callgraph. Once documents for AV1_COMP and MACROBLOCK are
- // added to doxygen, we can revert back to using the typedefs.
- void av1_rd_pick_intra_mode_sb(const struct AV1_COMP *cpi,
- struct macroblock *x, struct RD_STATS *rd_cost,
- BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
- int64_t best_rd) {
- const AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- const int num_planes = av1_num_planes(cm);
- TxfmSearchInfo *txfm_info = &x->txfm_search_info;
- int rate_y = 0, rate_uv = 0, rate_y_tokenonly = 0, rate_uv_tokenonly = 0;
- int y_skip_txfm = 0, uv_skip_txfm = 0;
- int64_t dist_y = 0, dist_uv = 0;
+ // Initialize default mode evaluation params
+ set_mode_eval_params(cpi, x, DEFAULT_EVAL);
- ctx->rd_stats.skip_txfm = 0;
- mbmi->ref_frame[0] = INTRA_FRAME;
- mbmi->ref_frame[1] = NONE_FRAME;
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
- if (xd->tree_type != CHROMA_PART) {
- mbmi->mv[0].as_int = 0;
- mbmi->skip_mode = 0;
- }
- const int64_t intra_yrd =
- (xd->tree_type == CHROMA_PART)
- ? 0
- : av1_rd_pick_intra_sby_mode(cpi, x, &rate_y, &rate_y_tokenonly,
- &dist_y, &y_skip_txfm, bsize, best_rd,
- ctx);
-
- // Initialize default mode evaluation params
- set_mode_eval_params(cpi, x, DEFAULT_EVAL);
-
- if (intra_yrd < best_rd) {
- // Search intra modes for uv planes if needed
- if (num_planes > 1 && xd->tree_type != LUMA_PART) {
- // Set up the tx variables for reproducing the y predictions in case we
- // need it for chroma-from-luma.
- if (xd->is_chroma_ref && store_cfl_required_rdo(cm, x)) {
- memcpy(txfm_info->blk_skip, ctx->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
- av1_copy_array(xd->tx_type_map, ctx->tx_type_map, ctx->num_4x4_blk);
- }
- const TX_SIZE max_uv_tx_size = av1_get_tx_size(AOM_PLANE_U, xd);
- av1_rd_pick_intra_sbuv_mode(cpi, x, &rate_uv, &rate_uv_tokenonly,
- &dist_uv, &uv_skip_txfm, bsize,
- max_uv_tx_size);
+ if (intra_yrd < best_rd) {
+ // Search intra modes for uv planes if needed
+ if (num_planes > 1 && xd->tree_type != LUMA_PART) {
+ // Set up the tx variables for reproducing the y predictions in case we
+ // need it for chroma-from-luma.
+ if (xd->is_chroma_ref && store_cfl_required_rdo(cm, x)) {
+ memcpy(txfm_info->blk_skip, ctx->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
+ av1_copy_array(xd->tx_type_map, ctx->tx_type_map, ctx->num_4x4_blk);
}
-
- // Intra block is always coded as non-skip
- rd_cost->rate =
- rate_y + rate_uv +
- x->mode_costs.skip_txfm_cost[av1_get_skip_txfm_context(xd)][0];
- rd_cost->dist = dist_y + dist_uv;
- rd_cost->rdcost = RDCOST(x->rdmult, rd_cost->rate, rd_cost->dist);
- rd_cost->skip_txfm = 0;
- } else {
- rd_cost->rate = INT_MAX;
+ const TX_SIZE max_uv_tx_size = av1_get_tx_size(AOM_PLANE_U, xd);
+ av1_rd_pick_intra_sbuv_mode(cpi, x, &rate_uv, &rate_uv_tokenonly,
+ &dist_uv, &uv_skip_txfm, bsize,
+ max_uv_tx_size);
}
- if (rd_cost->rate != INT_MAX && rd_cost->rdcost < best_rd)
- best_rd = rd_cost->rdcost;
- if (rd_pick_intrabc_mode_sb(cpi, x, ctx, rd_cost, bsize, best_rd) <
- best_rd) {
- ctx->rd_stats.skip_txfm = mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
- memcpy(ctx->blk_skip, txfm_info->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
- assert(rd_cost->rate != INT_MAX);
- }
- if (rd_cost->rate == INT_MAX) return;
-
- ctx->mic = *xd->mi[0];
- if (xd->tree_type != CHROMA_PART)
- av1_copy_mbmi_ext_to_mbmi_ext_frame(
- &ctx->mbmi_ext_best, x->mbmi_ext,
- av1_ref_frame_type(xd->mi[0]->ref_frame));
- av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
+ // Intra block is always coded as non-skip
+ rd_cost->rate =
+ rate_y + rate_uv +
+ x->mode_costs.skip_txfm_cost[av1_get_skip_txfm_context(xd)][0];
+ rd_cost->dist = dist_y + dist_uv;
+ rd_cost->rdcost = RDCOST(x->rdmult, rd_cost->rate, rd_cost->dist);
+ rd_cost->skip_txfm = 0;
+ } else {
+ rd_cost->rate = INT_MAX;
}
- static AOM_INLINE void calc_target_weighted_pred(
- const AV1_COMMON *cm, const MACROBLOCK *x, const MACROBLOCKD *xd,
- const uint8_t *above, int above_stride, const uint8_t *left,
- int left_stride);
+ if (rd_cost->rate != INT_MAX && rd_cost->rdcost < best_rd)
+ best_rd = rd_cost->rdcost;
+ if (rd_pick_intrabc_mode_sb(cpi, x, ctx, rd_cost, bsize, best_rd) < best_rd) {
+ ctx->rd_stats.skip_txfm = mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
+ memcpy(ctx->blk_skip, txfm_info->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
+ assert(rd_cost->rate != INT_MAX);
+ }
+ if (rd_cost->rate == INT_MAX) return;
+
+ ctx->mic = *xd->mi[0];
+ if (xd->tree_type != CHROMA_PART)
+ av1_copy_mbmi_ext_to_mbmi_ext_frame(
+ &ctx->mbmi_ext_best, x->mbmi_ext,
+ av1_ref_frame_type(xd->mi[0]->ref_frame));
+ av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
+}
+
+static AOM_INLINE void calc_target_weighted_pred(
+ const AV1_COMMON *cm, const MACROBLOCK *x, const MACROBLOCKD *xd,
+ const uint8_t *above, int above_stride, const uint8_t *left,
+ int left_stride);
#if CONFIG_SKIP_MODE_ENHANCEMENT
- /*!\brief Search for the best skip mode
- *
- * \ingroup av1_rd_pick_inter_mode_sb
- *
- * This function performs a rate distortion search to find the best skip mode
- * and compare the existing best mode
- *
- * Nothing is returned. The best mode is saved within the funtion
- */
- static AOM_INLINE void rd_pick_motion_copy_mode(
- InterModeSearchState * search_state, const AV1_COMP *cpi, MACROBLOCK *x,
- BLOCK_SIZE bsize, struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE],
- PICK_MODE_CONTEXT *ctx, RD_STATS *best_rd_cost) {
- const AV1_COMMON *const cm = &cpi->common;
- const SkipModeInfo *const skip_mode_info =
- &cm->current_frame.skip_mode_info;
- const int num_planes = av1_num_planes(cm);
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- TxfmSearchInfo *txfm_info = &x->txfm_search_info;
- const TxfmSearchParams *txfm_params = &x->txfm_search_params;
+/*!\brief Search for the best skip mode
+ *
+ * \ingroup av1_rd_pick_inter_mode_sb
+ *
+ * This function performs a rate distortion search to find the best skip mode
+ * and compare the existing best mode
+ *
+ * Nothing is returned. The best mode is saved within the funtion
+ */
+static AOM_INLINE void rd_pick_motion_copy_mode(
+ InterModeSearchState *search_state, const AV1_COMP *cpi, MACROBLOCK *x,
+ BLOCK_SIZE bsize, struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE],
+ PICK_MODE_CONTEXT *ctx, RD_STATS *best_rd_cost) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const SkipModeInfo *const skip_mode_info = &cm->current_frame.skip_mode_info;
+ const int num_planes = av1_num_planes(cm);
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ TxfmSearchInfo *txfm_info = &x->txfm_search_info;
+ const TxfmSearchParams *txfm_params = &x->txfm_search_params;
- if (skip_mode_info->ref_frame_idx_0 == INVALID_IDX ||
- skip_mode_info->ref_frame_idx_1 == INVALID_IDX) {
- return;
- }
+ if (skip_mode_info->ref_frame_idx_0 == INVALID_IDX ||
+ skip_mode_info->ref_frame_idx_1 == INVALID_IDX) {
+ return;
+ }
#if CONFIG_NEW_REF_SIGNALING
- const MV_REFERENCE_FRAME ref_frame = skip_mode_info->ref_frame_idx_0;
- const MV_REFERENCE_FRAME second_ref_frame = skip_mode_info->ref_frame_idx_1;
+ const MV_REFERENCE_FRAME ref_frame = skip_mode_info->ref_frame_idx_0;
+ const MV_REFERENCE_FRAME second_ref_frame = skip_mode_info->ref_frame_idx_1;
#else
const MV_REFERENCE_FRAME ref_frame =
LAST_FRAME + skip_mode_info->ref_frame_idx_0;
@@ -5265,238 +4871,236 @@
#endif
#if CONFIG_OPTFLOW_REFINEMENT
- const PREDICTION_MODE this_mode =
- cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV;
+ const PREDICTION_MODE this_mode =
+ cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV;
#else
const PREDICTION_MODE this_mode = NEAR_NEARMV;
#endif // CONFIG_OPTFLOW_REFINEMENT
#if !CONFIG_NEW_REF_SIGNALING
- const THR_MODES mode_index =
- get_prediction_mode_idx(this_mode, ref_frame, second_ref_frame);
+ const THR_MODES mode_index =
+ get_prediction_mode_idx(this_mode, ref_frame, second_ref_frame);
- if (mode_index == THR_INVALID) {
- return;
- }
+ if (mode_index == THR_INVALID) {
+ return;
+ }
#endif
- if ((!cpi->oxcf.ref_frm_cfg.enable_onesided_comp ||
- cpi->sf.inter_sf.disable_onesided_comp) &&
- cpi->all_one_sided_refs) {
+ if ((!cpi->oxcf.ref_frm_cfg.enable_onesided_comp ||
+ cpi->sf.inter_sf.disable_onesided_comp) &&
+ cpi->all_one_sided_refs) {
+ return;
+ }
+
+ mbmi->mode = this_mode;
+ mbmi->ref_mv_idx = 0;
+ mbmi->uv_mode = UV_DC_PRED;
+ mbmi->ref_frame[0] = ref_frame;
+ mbmi->ref_frame[1] = second_ref_frame;
+#if CONFIG_IBC_SR_EXT
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
+#endif // CONFIG_IBC_SR_EXT
+ const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
+ if (x->mbmi_ext->ref_mv_count[ref_frame_type] == UINT8_MAX) {
+ if (x->mbmi_ext->ref_mv_count[ref_frame] == UINT8_MAX ||
+ x->mbmi_ext->ref_mv_count[second_ref_frame] == UINT8_MAX) {
return;
}
-
- mbmi->mode = this_mode;
- mbmi->ref_mv_idx = 0;
- mbmi->uv_mode = UV_DC_PRED;
- mbmi->ref_frame[0] = ref_frame;
- mbmi->ref_frame[1] = second_ref_frame;
-#if CONFIG_IBC_SR_EXT
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
-#endif // CONFIG_IBC_SR_EXT
- const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
- if (x->mbmi_ext->ref_mv_count[ref_frame_type] == UINT8_MAX) {
- if (x->mbmi_ext->ref_mv_count[ref_frame] == UINT8_MAX ||
- x->mbmi_ext->ref_mv_count[second_ref_frame] == UINT8_MAX) {
- return;
- }
- MB_MODE_INFO_EXT *mbmi_ext = x->mbmi_ext;
- av1_find_mv_refs(cm, xd, mbmi, ref_frame_type, mbmi_ext->ref_mv_count,
- xd->ref_mv_stack, xd->weight, NULL, mbmi_ext->global_mvs,
- mbmi_ext->mode_context);
- // TODO(Ravi): Populate mbmi_ext->ref_mv_stack[ref_frame][4] and
- // mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
- av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame_type);
- }
+ MB_MODE_INFO_EXT *mbmi_ext = x->mbmi_ext;
+ av1_find_mv_refs(cm, xd, mbmi, ref_frame_type, mbmi_ext->ref_mv_count,
+ xd->ref_mv_stack, xd->weight, NULL, mbmi_ext->global_mvs,
+ mbmi_ext->mode_context);
+ // TODO(Ravi): Populate mbmi_ext->ref_mv_stack[ref_frame][4] and
+ // mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
+ av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame_type);
+ }
#if CONFIG_OPTFLOW_REFINEMENT
- assert(this_mode ==
- (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV));
- assert(mbmi->mode ==
- (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV));
+ assert(this_mode ==
+ (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV));
+ assert(mbmi->mode ==
+ (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV));
#else
assert(this_mode == NEAR_NEARMV);
assert(mbmi->mode == NEAR_NEARMV);
#endif
- assert(mbmi->ref_mv_idx == 0);
- if (!build_cur_mv(mbmi->mv, this_mode, cm, x, 0)) {
- assert(av1_check_newmv_joint_nonzero(cm, x));
- return;
- }
+ assert(mbmi->ref_mv_idx == 0);
+ if (!build_cur_mv(mbmi->mv, this_mode, cm, x, 0)) {
+ assert(av1_check_newmv_joint_nonzero(cm, x));
+ return;
+ }
#if CONFIG_FORWARDSKIP
- mbmi->fsc_mode[xd->tree_type == CHROMA_PART] = 0;
+ mbmi->fsc_mode[xd->tree_type == CHROMA_PART] = 0;
#endif
- mbmi->filter_intra_mode_info.use_filter_intra = 0;
- mbmi->interintra_mode = (INTERINTRA_MODE)(II_DC_PRED - 1);
- mbmi->comp_group_idx = 0;
- mbmi->interinter_comp.type = COMPOUND_AVERAGE;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->ref_mv_idx = 0;
- mbmi->skip_mode = mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1;
+ mbmi->filter_intra_mode_info.use_filter_intra = 0;
+ mbmi->interintra_mode = (INTERINTRA_MODE)(II_DC_PRED - 1);
+ mbmi->comp_group_idx = 0;
+ mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->ref_mv_idx = 0;
+ mbmi->skip_mode = mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1;
- set_default_interp_filters(mbmi,
+ set_default_interp_filters(mbmi,
#if CONFIG_OPTFLOW_REFINEMENT
- cm,
+ cm,
#endif // CONFIG_OPTFLOW_REFINEMENT
- cm->features.interp_filter);
+ cm->features.interp_filter);
- set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
- for (int i = 0; i < num_planes; i++) {
- xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
- xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i];
+ set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+ for (int i = 0; i < num_planes; i++) {
+ xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
+ xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i];
+ }
+
+ BUFFER_SET orig_dst;
+ for (int i = 0; i < num_planes; i++) {
+ orig_dst.plane[i] = xd->plane[i].dst.buf;
+ orig_dst.stride[i] = xd->plane[i].dst.stride;
+ }
+
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
+
+ // Compare the use of skip_mode with the best intra/inter mode obtained.
+ const ModeCosts *mode_costs = &x->mode_costs;
+ const int skip_mode_ctx = av1_get_skip_mode_context(xd);
+ if (best_rd_cost->dist < INT64_MAX && best_rd_cost->rate < INT32_MAX) {
+ // Account for non-skip mode rate in total rd stats
+ best_rd_cost->rate += mode_costs->skip_mode_cost[skip_mode_ctx][0];
+ av1_rd_cost_update(x->rdmult, best_rd_cost);
+ search_state->best_rd = best_rd_cost->rdcost;
+ }
+ // loop of ref_mv_idx
+ const int ref_set = get_drl_refmv_count(cm->features.max_drl_bits, x,
+ mbmi->ref_frame, this_mode);
+
+ for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ref_mv_idx++) {
+ mbmi->ref_mv_idx = ref_mv_idx;
+
+ if (!build_cur_mv(mbmi->mv, this_mode, cm, x, 0)) {
+ assert(av1_check_newmv_joint_nonzero(cm, x));
+ continue;
}
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, bsize, 0,
+ av1_num_planes(cm) - 1);
- BUFFER_SET orig_dst;
- for (int i = 0; i < num_planes; i++) {
- orig_dst.plane[i] = xd->plane[i].dst.buf;
- orig_dst.stride[i] = xd->plane[i].dst.stride;
- }
+ RD_STATS skip_mode_rd_stats, skip_mode_rd_stats_y, skip_mode_rd_stats_uv;
+ av1_invalid_rd_stats(&skip_mode_rd_stats);
+ av1_invalid_rd_stats(&skip_mode_rd_stats_y);
+ av1_invalid_rd_stats(&skip_mode_rd_stats_uv);
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
+ skip_mode_rd_stats.rate = mode_costs->skip_mode_cost[skip_mode_ctx][1];
- // Compare the use of skip_mode with the best intra/inter mode obtained.
- const ModeCosts *mode_costs = &x->mode_costs;
- const int skip_mode_ctx = av1_get_skip_mode_context(xd);
- if (best_rd_cost->dist < INT64_MAX && best_rd_cost->rate < INT32_MAX) {
- // Account for non-skip mode rate in total rd stats
- best_rd_cost->rate += mode_costs->skip_mode_cost[skip_mode_ctx][0];
- av1_rd_cost_update(x->rdmult, best_rd_cost);
- search_state->best_rd = best_rd_cost->rdcost;
- }
- // loop of ref_mv_idx
- const int ref_set = get_drl_refmv_count(cm->features.max_drl_bits, x,
- mbmi->ref_frame, this_mode);
+ // add ref_mv_idx rate
+ MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
+ const int drl_cost =
+ get_drl_cost(cpi->common.features.max_drl_bits, mbmi, mbmi_ext, x);
+ skip_mode_rd_stats.rate += drl_cost;
- for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ref_mv_idx++) {
- mbmi->ref_mv_idx = ref_mv_idx;
-
- if (!build_cur_mv(mbmi->mv, this_mode, cm, x, 0)) {
- assert(av1_check_newmv_joint_nonzero(cm, x));
- continue;
- }
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, bsize, 0,
- av1_num_planes(cm) - 1);
-
- RD_STATS skip_mode_rd_stats, skip_mode_rd_stats_y, skip_mode_rd_stats_uv;
+ // Do transform search
+ if (av1_txfm_search(cpi, x, bsize, &skip_mode_rd_stats,
+ &skip_mode_rd_stats_y, &skip_mode_rd_stats_uv,
+ skip_mode_rd_stats.rate, search_state->best_rd)) {
+ skip_mode_rd_stats.rdcost =
+ RDCOST(x->rdmult, skip_mode_rd_stats.rate, skip_mode_rd_stats.dist);
+ } else {
av1_invalid_rd_stats(&skip_mode_rd_stats);
av1_invalid_rd_stats(&skip_mode_rd_stats_y);
av1_invalid_rd_stats(&skip_mode_rd_stats_uv);
+ }
- skip_mode_rd_stats.rate = mode_costs->skip_mode_cost[skip_mode_ctx][1];
-
- // add ref_mv_idx rate
- MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
- const int drl_cost =
- get_drl_cost(cpi->common.features.max_drl_bits, mbmi, mbmi_ext, x);
- skip_mode_rd_stats.rate += drl_cost;
-
- // Do transform search
- if (av1_txfm_search(cpi, x, bsize, &skip_mode_rd_stats,
- &skip_mode_rd_stats_y, &skip_mode_rd_stats_uv,
- skip_mode_rd_stats.rate, search_state->best_rd)) {
- skip_mode_rd_stats.rdcost =
- RDCOST(x->rdmult, skip_mode_rd_stats.rate, skip_mode_rd_stats.dist);
- } else {
- av1_invalid_rd_stats(&skip_mode_rd_stats);
- av1_invalid_rd_stats(&skip_mode_rd_stats_y);
- av1_invalid_rd_stats(&skip_mode_rd_stats_uv);
- }
-
- if (skip_mode_rd_stats.rdcost < search_state->best_rd &&
- (!xd->lossless[mbmi->segment_id] || skip_mode_rd_stats.dist == 0)) {
+ if (skip_mode_rd_stats.rdcost < search_state->best_rd &&
+ (!xd->lossless[mbmi->segment_id] || skip_mode_rd_stats.dist == 0)) {
#if !CONFIG_NEW_REF_SIGNALING
- assert(mode_index != THR_INVALID);
+ assert(mode_index != THR_INVALID);
#endif // !CONFIG_NEW_REF_SIGNALING
- assert(mbmi->skip_txfm[xd->tree_type == CHROMA_PART] ==
- skip_mode_rd_stats.skip_txfm);
- search_state->best_mbmode.skip_mode = 1;
- search_state->best_mbmode = *mbmi;
- search_state->best_mbmode.skip_txfm[xd->tree_type == CHROMA_PART] =
- mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
+ assert(mbmi->skip_txfm[xd->tree_type == CHROMA_PART] ==
+ skip_mode_rd_stats.skip_txfm);
+ search_state->best_mbmode.skip_mode = 1;
+ search_state->best_mbmode = *mbmi;
+ search_state->best_mbmode.skip_txfm[xd->tree_type == CHROMA_PART] =
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
#if CONFIG_FORWARDSKIP
- search_state->best_mbmode.fsc_mode[xd->tree_type == CHROMA_PART] = 0;
+ search_state->best_mbmode.fsc_mode[xd->tree_type == CHROMA_PART] = 0;
#endif
#if CONFIG_OPTFLOW_REFINEMENT
- search_state->best_mbmode.mode =
- (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV);
+ search_state->best_mbmode.mode =
+ (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV);
#else
search_state->best_mbmode.mode = NEAR_NEARMV;
#endif // CONFIG_OPTFLOW_REFINEMENT
- search_state->best_mbmode.ref_frame[0] = mbmi->ref_frame[0];
- search_state->best_mbmode.ref_frame[1] = mbmi->ref_frame[1];
- search_state->best_mbmode.mv[0].as_int = mbmi->mv[0].as_int;
- search_state->best_mbmode.mv[1].as_int = mbmi->mv[1].as_int;
- search_state->best_mbmode.ref_mv_idx = mbmi->ref_mv_idx;
+ search_state->best_mbmode.ref_frame[0] = mbmi->ref_frame[0];
+ search_state->best_mbmode.ref_frame[1] = mbmi->ref_frame[1];
+ search_state->best_mbmode.mv[0].as_int = mbmi->mv[0].as_int;
+ search_state->best_mbmode.mv[1].as_int = mbmi->mv[1].as_int;
+ search_state->best_mbmode.ref_mv_idx = mbmi->ref_mv_idx;
- // Set up tx_size related variables for skip-specific loop filtering.
- if (search_state->best_mbmode.skip_txfm[xd->tree_type == CHROMA_PART]) {
- search_state->best_mbmode.tx_size =
- block_signals_txsize(bsize)
- ? tx_size_from_tx_mode(bsize,
- txfm_params->tx_mode_search_type)
- : max_txsize_rect_lookup[bsize];
- memset(search_state->best_mbmode.inter_tx_size,
- search_state->best_mbmode.tx_size,
- sizeof(search_state->best_mbmode.inter_tx_size));
- set_txfm_ctxs(search_state->best_mbmode.tx_size, xd->width,
- xd->height,
- search_state->best_mbmode
- .skip_txfm[xd->tree_type == CHROMA_PART] &&
- is_inter_block(mbmi, xd->tree_type),
- xd);
+ // Set up tx_size related variables for skip-specific loop filtering.
+ if (search_state->best_mbmode.skip_txfm[xd->tree_type == CHROMA_PART]) {
+ search_state->best_mbmode.tx_size =
+ block_signals_txsize(bsize)
+ ? tx_size_from_tx_mode(bsize, txfm_params->tx_mode_search_type)
+ : max_txsize_rect_lookup[bsize];
+ memset(search_state->best_mbmode.inter_tx_size,
+ search_state->best_mbmode.tx_size,
+ sizeof(search_state->best_mbmode.inter_tx_size));
+ set_txfm_ctxs(
+ search_state->best_mbmode.tx_size, xd->width, xd->height,
+ search_state->best_mbmode.skip_txfm[xd->tree_type == CHROMA_PART] &&
+ is_inter_block(mbmi, xd->tree_type),
+ xd);
- x->txfm_search_info.skip_txfm = 1;
- search_state->best_mode_skippable = 1;
- search_state->best_skip2 = 1;
+ x->txfm_search_info.skip_txfm = 1;
+ search_state->best_mode_skippable = 1;
+ search_state->best_skip2 = 1;
- restore_dst_buf(xd, orig_dst, num_planes);
- } else {
- x->txfm_search_info.skip_txfm = 0;
- memcpy(ctx->blk_skip, txfm_info->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
- av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
- search_state->best_mode_skippable = 0;
- search_state->best_skip2 = 0;
- search_state->best_rate_y =
- skip_mode_rd_stats_y.rate +
- x->mode_costs.skip_txfm_cost[av1_get_skip_txfm_context(xd)][0];
- search_state->best_rate_uv = skip_mode_rd_stats_uv.rate;
- }
-
- // Set up color-related variables for skip mode.
- search_state->best_mbmode.uv_mode = UV_DC_PRED;
- search_state->best_mbmode.palette_mode_info.palette_size[0] = 0;
- search_state->best_mbmode.palette_mode_info.palette_size[1] = 0;
-
- search_state->best_mbmode.comp_group_idx = 0;
- search_state->best_mbmode.interinter_comp.type = COMPOUND_AVERAGE;
- search_state->best_mbmode.motion_mode = SIMPLE_TRANSLATION;
-
- search_state->best_mbmode.interintra_mode =
- (INTERINTRA_MODE)(II_DC_PRED - 1);
- search_state->best_mbmode.filter_intra_mode_info.use_filter_intra = 0;
-
- set_default_interp_filters(&search_state->best_mbmode,
-#if CONFIG_OPTFLOW_REFINEMENT
- cm,
-#endif // CONFIG_OPTFLOW_REFINEMENT
- cm->features.interp_filter);
-
- // Update rd_cost
- best_rd_cost->rate = skip_mode_rd_stats.rate;
- best_rd_cost->dist = best_rd_cost->sse = skip_mode_rd_stats.dist;
- best_rd_cost->rdcost = skip_mode_rd_stats.rdcost;
-
- search_state->best_rd = best_rd_cost->rdcost;
+ restore_dst_buf(xd, orig_dst, num_planes);
+ } else {
+ x->txfm_search_info.skip_txfm = 0;
+ memcpy(ctx->blk_skip, txfm_info->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
+ av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
+ search_state->best_mode_skippable = 0;
+ search_state->best_skip2 = 0;
+ search_state->best_rate_y =
+ skip_mode_rd_stats_y.rate +
+ x->mode_costs.skip_txfm_cost[av1_get_skip_txfm_context(xd)][0];
+ search_state->best_rate_uv = skip_mode_rd_stats_uv.rate;
}
+
+ // Set up color-related variables for skip mode.
+ search_state->best_mbmode.uv_mode = UV_DC_PRED;
+ search_state->best_mbmode.palette_mode_info.palette_size[0] = 0;
+ search_state->best_mbmode.palette_mode_info.palette_size[1] = 0;
+
+ search_state->best_mbmode.comp_group_idx = 0;
+ search_state->best_mbmode.interinter_comp.type = COMPOUND_AVERAGE;
+ search_state->best_mbmode.motion_mode = SIMPLE_TRANSLATION;
+
+ search_state->best_mbmode.interintra_mode =
+ (INTERINTRA_MODE)(II_DC_PRED - 1);
+ search_state->best_mbmode.filter_intra_mode_info.use_filter_intra = 0;
+
+ set_default_interp_filters(&search_state->best_mbmode,
+#if CONFIG_OPTFLOW_REFINEMENT
+ cm,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ cm->features.interp_filter);
+
+ // Update rd_cost
+ best_rd_cost->rate = skip_mode_rd_stats.rate;
+ best_rd_cost->dist = best_rd_cost->sse = skip_mode_rd_stats.dist;
+ best_rd_cost->rdcost = skip_mode_rd_stats.rdcost;
+
+ search_state->best_rd = best_rd_cost->rdcost;
}
- assert(av1_check_newmv_joint_nonzero(cm, x));
}
+ assert(av1_check_newmv_joint_nonzero(cm, x));
+}
#else // CONFIG_SKIP_MODE_ENHANCEMENT
static AOM_INLINE void rd_pick_skip_mode(
RD_STATS *rd_cost, InterModeSearchState *search_state,
@@ -5715,210 +5319,210 @@
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
- // Get winner mode stats of given mode index
- static AOM_INLINE MB_MODE_INFO *get_winner_mode_stats(
- MACROBLOCK * x, MB_MODE_INFO * best_mbmode, RD_STATS * best_rd_cost,
- int best_rate_y, int best_rate_uv, RD_STATS **winner_rd_cost,
- int *winner_rate_y, int *winner_rate_uv, PREDICTION_MODE *winner_mode,
- MULTI_WINNER_MODE_TYPE multi_winner_mode_type, int mode_idx) {
- MB_MODE_INFO *winner_mbmi;
- if (multi_winner_mode_type) {
- assert(mode_idx >= 0 && mode_idx < x->winner_mode_count);
- WinnerModeStats *winner_mode_stat = &x->winner_mode_stats[mode_idx];
- winner_mbmi = &winner_mode_stat->mbmi;
+// Get winner mode stats of given mode index
+static AOM_INLINE MB_MODE_INFO *get_winner_mode_stats(
+ MACROBLOCK *x, MB_MODE_INFO *best_mbmode, RD_STATS *best_rd_cost,
+ int best_rate_y, int best_rate_uv, RD_STATS **winner_rd_cost,
+ int *winner_rate_y, int *winner_rate_uv, PREDICTION_MODE *winner_mode,
+ MULTI_WINNER_MODE_TYPE multi_winner_mode_type, int mode_idx) {
+ MB_MODE_INFO *winner_mbmi;
+ if (multi_winner_mode_type) {
+ assert(mode_idx >= 0 && mode_idx < x->winner_mode_count);
+ WinnerModeStats *winner_mode_stat = &x->winner_mode_stats[mode_idx];
+ winner_mbmi = &winner_mode_stat->mbmi;
- *winner_rd_cost = &winner_mode_stat->rd_cost;
- *winner_rate_y = winner_mode_stat->rate_y;
- *winner_rate_uv = winner_mode_stat->rate_uv;
- *winner_mode = winner_mode_stat->mode;
- } else {
- winner_mbmi = best_mbmode;
- *winner_rd_cost = best_rd_cost;
- *winner_rate_y = best_rate_y;
- *winner_rate_uv = best_rate_uv;
- *winner_mode = best_mbmode->mode;
- }
- return winner_mbmi;
+ *winner_rd_cost = &winner_mode_stat->rd_cost;
+ *winner_rate_y = winner_mode_stat->rate_y;
+ *winner_rate_uv = winner_mode_stat->rate_uv;
+ *winner_mode = winner_mode_stat->mode;
+ } else {
+ winner_mbmi = best_mbmode;
+ *winner_rd_cost = best_rd_cost;
+ *winner_rate_y = best_rate_y;
+ *winner_rate_uv = best_rate_uv;
+ *winner_mode = best_mbmode->mode;
}
+ return winner_mbmi;
+}
- // speed feature: fast intra/inter transform type search
- // Used for speed >= 2
- // When this speed feature is on, in rd mode search, only DCT is used.
- // After the mode is determined, this function is called, to select
- // transform types and get accurate rdcost.
- static AOM_INLINE void refine_winner_mode_tx(
- const AV1_COMP *cpi, MACROBLOCK *x, RD_STATS *rd_cost, BLOCK_SIZE bsize,
- PICK_MODE_CONTEXT *ctx, MB_MODE_INFO *best_mbmode,
- struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE], int best_rate_y,
- int best_rate_uv, int *best_skip2, int winner_mode_count) {
- const AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- TxfmSearchParams *txfm_params = &x->txfm_search_params;
- TxfmSearchInfo *txfm_info = &x->txfm_search_info;
- int64_t best_rd;
- const int num_planes = av1_num_planes(cm);
+// speed feature: fast intra/inter transform type search
+// Used for speed >= 2
+// When this speed feature is on, in rd mode search, only DCT is used.
+// After the mode is determined, this function is called, to select
+// transform types and get accurate rdcost.
+static AOM_INLINE void refine_winner_mode_tx(
+ const AV1_COMP *cpi, MACROBLOCK *x, RD_STATS *rd_cost, BLOCK_SIZE bsize,
+ PICK_MODE_CONTEXT *ctx, MB_MODE_INFO *best_mbmode,
+ struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE], int best_rate_y,
+ int best_rate_uv, int *best_skip2, int winner_mode_count) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ TxfmSearchParams *txfm_params = &x->txfm_search_params;
+ TxfmSearchInfo *txfm_info = &x->txfm_search_info;
+ int64_t best_rd;
+ const int num_planes = av1_num_planes(cm);
- if (!is_winner_mode_processing_enabled(cpi, best_mbmode, best_mbmode->mode))
- return;
+ if (!is_winner_mode_processing_enabled(cpi, best_mbmode, best_mbmode->mode))
+ return;
- // Set params for winner mode evaluation
- set_mode_eval_params(cpi, x, WINNER_MODE_EVAL);
+ // Set params for winner mode evaluation
+ set_mode_eval_params(cpi, x, WINNER_MODE_EVAL);
- // No best mode identified so far
- if (best_mbmode->mode == MODE_INVALID) return;
+ // No best mode identified so far
+ if (best_mbmode->mode == MODE_INVALID) return;
- best_rd = RDCOST(x->rdmult, rd_cost->rate, rd_cost->dist);
- for (int mode_idx = 0; mode_idx < winner_mode_count; mode_idx++) {
- RD_STATS *winner_rd_stats = NULL;
- int winner_rate_y = 0, winner_rate_uv = 0;
- PREDICTION_MODE winner_mode = 0;
+ best_rd = RDCOST(x->rdmult, rd_cost->rate, rd_cost->dist);
+ for (int mode_idx = 0; mode_idx < winner_mode_count; mode_idx++) {
+ RD_STATS *winner_rd_stats = NULL;
+ int winner_rate_y = 0, winner_rate_uv = 0;
+ PREDICTION_MODE winner_mode = 0;
- // TODO(any): Combine best mode and multi-winner mode processing paths
- // Get winner mode stats for current mode index
- MB_MODE_INFO *winner_mbmi = get_winner_mode_stats(
- x, best_mbmode, rd_cost, best_rate_y, best_rate_uv, &winner_rd_stats,
- &winner_rate_y, &winner_rate_uv, &winner_mode,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, mode_idx);
+ // TODO(any): Combine best mode and multi-winner mode processing paths
+ // Get winner mode stats for current mode index
+ MB_MODE_INFO *winner_mbmi = get_winner_mode_stats(
+ x, best_mbmode, rd_cost, best_rate_y, best_rate_uv, &winner_rd_stats,
+ &winner_rate_y, &winner_rate_uv, &winner_mode,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type, mode_idx);
- if (xd->lossless[winner_mbmi->segment_id] == 0 &&
- winner_mode != MODE_INVALID &&
- is_winner_mode_processing_enabled(cpi, winner_mbmi,
- winner_mbmi->mode)) {
- RD_STATS rd_stats = *winner_rd_stats;
- int skip_blk = 0;
- RD_STATS rd_stats_y, rd_stats_uv;
- const int skip_ctx = av1_get_skip_txfm_context(xd);
+ if (xd->lossless[winner_mbmi->segment_id] == 0 &&
+ winner_mode != MODE_INVALID &&
+ is_winner_mode_processing_enabled(cpi, winner_mbmi,
+ winner_mbmi->mode)) {
+ RD_STATS rd_stats = *winner_rd_stats;
+ int skip_blk = 0;
+ RD_STATS rd_stats_y, rd_stats_uv;
+ const int skip_ctx = av1_get_skip_txfm_context(xd);
- *mbmi = *winner_mbmi;
+ *mbmi = *winner_mbmi;
- set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+ set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
- // Select prediction reference frames.
- for (int i = 0; i < num_planes; i++) {
+ // Select prediction reference frames.
+ for (int i = 0; i < num_planes; i++) {
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- xd->plane[i].pre[0] =
- yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[0])][i];
- if (has_second_ref(mbmi))
- xd->plane[i].pre[1] =
- yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[1])][i];
+ xd->plane[i].pre[0] =
+ yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[0])][i];
+ if (has_second_ref(mbmi))
+ xd->plane[i].pre[1] =
+ yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[1])][i];
#else
xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
if (has_second_ref(mbmi))
xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i];
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- }
+ }
- if (is_inter_mode(mbmi->mode)) {
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
- av1_num_planes(cm) - 1);
- if (mbmi->motion_mode == OBMC_CAUSAL)
- av1_build_obmc_inter_predictors_sb(cm, xd);
+ if (is_inter_mode(mbmi->mode)) {
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
+ av1_num_planes(cm) - 1);
+ if (mbmi->motion_mode == OBMC_CAUSAL)
+ av1_build_obmc_inter_predictors_sb(cm, xd);
- av1_subtract_plane(x, bsize, 0);
- if (txfm_params->tx_mode_search_type == TX_MODE_SELECT &&
- !xd->lossless[mbmi->segment_id]) {
- av1_pick_recursive_tx_size_type_yrd(cpi, x, &rd_stats_y, bsize,
- INT64_MAX);
- assert(rd_stats_y.rate != INT_MAX);
- } else {
- av1_pick_uniform_tx_size_type_yrd(cpi, x, &rd_stats_y, bsize,
+ av1_subtract_plane(x, bsize, 0);
+ if (txfm_params->tx_mode_search_type == TX_MODE_SELECT &&
+ !xd->lossless[mbmi->segment_id]) {
+ av1_pick_recursive_tx_size_type_yrd(cpi, x, &rd_stats_y, bsize,
INT64_MAX);
- memset(mbmi->inter_tx_size, mbmi->tx_size,
- sizeof(mbmi->inter_tx_size));
- for (int i = 0; i < xd->height * xd->width; ++i)
- set_blk_skip(txfm_info->blk_skip, 0, i, rd_stats_y.skip_txfm);
- }
+ assert(rd_stats_y.rate != INT_MAX);
} else {
av1_pick_uniform_tx_size_type_yrd(cpi, x, &rd_stats_y, bsize,
INT64_MAX);
+ memset(mbmi->inter_tx_size, mbmi->tx_size,
+ sizeof(mbmi->inter_tx_size));
+ for (int i = 0; i < xd->height * xd->width; ++i)
+ set_blk_skip(txfm_info->blk_skip, 0, i, rd_stats_y.skip_txfm);
}
+ } else {
+ av1_pick_uniform_tx_size_type_yrd(cpi, x, &rd_stats_y, bsize,
+ INT64_MAX);
+ }
- if (num_planes > 1) {
- av1_txfm_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
- } else {
- av1_init_rd_stats(&rd_stats_uv);
- }
+ if (num_planes > 1) {
+ av1_txfm_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
+ } else {
+ av1_init_rd_stats(&rd_stats_uv);
+ }
- const ModeCosts *mode_costs = &x->mode_costs;
- if (is_inter_mode(mbmi->mode) &&
- RDCOST(x->rdmult,
- mode_costs->skip_txfm_cost[skip_ctx][0] + rd_stats_y.rate +
- rd_stats_uv.rate,
- (rd_stats_y.dist + rd_stats_uv.dist)) >
- RDCOST(x->rdmult, mode_costs->skip_txfm_cost[skip_ctx][1],
- (rd_stats_y.sse + rd_stats_uv.sse))) {
- skip_blk = 1;
- rd_stats_y.rate = mode_costs->skip_txfm_cost[skip_ctx][1];
- rd_stats_uv.rate = 0;
- rd_stats_y.dist = rd_stats_y.sse;
- rd_stats_uv.dist = rd_stats_uv.sse;
- } else {
- skip_blk = 0;
- rd_stats_y.rate += mode_costs->skip_txfm_cost[skip_ctx][0];
- }
- int this_rate = rd_stats.rate + rd_stats_y.rate + rd_stats_uv.rate -
- winner_rate_y - winner_rate_uv;
- int64_t this_rd =
- RDCOST(x->rdmult, this_rate, (rd_stats_y.dist + rd_stats_uv.dist));
- if (best_rd > this_rd) {
- *best_mbmode = *mbmi;
- av1_copy_array(ctx->blk_skip, txfm_info->blk_skip, ctx->num_4x4_blk);
- av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
- rd_cost->rate = this_rate;
- rd_cost->dist = rd_stats_y.dist + rd_stats_uv.dist;
- rd_cost->sse = rd_stats_y.sse + rd_stats_uv.sse;
- rd_cost->rdcost = this_rd;
- best_rd = this_rd;
- *best_skip2 = skip_blk;
- }
+ const ModeCosts *mode_costs = &x->mode_costs;
+ if (is_inter_mode(mbmi->mode) &&
+ RDCOST(x->rdmult,
+ mode_costs->skip_txfm_cost[skip_ctx][0] + rd_stats_y.rate +
+ rd_stats_uv.rate,
+ (rd_stats_y.dist + rd_stats_uv.dist)) >
+ RDCOST(x->rdmult, mode_costs->skip_txfm_cost[skip_ctx][1],
+ (rd_stats_y.sse + rd_stats_uv.sse))) {
+ skip_blk = 1;
+ rd_stats_y.rate = mode_costs->skip_txfm_cost[skip_ctx][1];
+ rd_stats_uv.rate = 0;
+ rd_stats_y.dist = rd_stats_y.sse;
+ rd_stats_uv.dist = rd_stats_uv.sse;
+ } else {
+ skip_blk = 0;
+ rd_stats_y.rate += mode_costs->skip_txfm_cost[skip_ctx][0];
+ }
+ int this_rate = rd_stats.rate + rd_stats_y.rate + rd_stats_uv.rate -
+ winner_rate_y - winner_rate_uv;
+ int64_t this_rd =
+ RDCOST(x->rdmult, this_rate, (rd_stats_y.dist + rd_stats_uv.dist));
+ if (best_rd > this_rd) {
+ *best_mbmode = *mbmi;
+ av1_copy_array(ctx->blk_skip, txfm_info->blk_skip, ctx->num_4x4_blk);
+ av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
+ rd_cost->rate = this_rate;
+ rd_cost->dist = rd_stats_y.dist + rd_stats_uv.dist;
+ rd_cost->sse = rd_stats_y.sse + rd_stats_uv.sse;
+ rd_cost->rdcost = this_rd;
+ best_rd = this_rd;
+ *best_skip2 = skip_blk;
}
}
}
+}
- /*!\cond */
- typedef struct {
- // Mask for each reference frame, specifying which prediction modes to NOT
- // try during search.
- uint32_t pred_modes[REF_FRAMES];
- // If ref_combo[i][j + 1] is true, do NOT try prediction using combination
- // of reference frames (i, j). Indexing with 'j + 1' is due to the fact that
- // 2nd reference can be -1 (INVALID_FRAME). NOTE: In
- // CONFIG_NEW_REF_SIGNALING, indexing for the reference has the order the
- // INTER references followed by INTRA
- bool ref_combo[REF_FRAMES][REF_FRAMES + 1];
- } mode_skip_mask_t;
- /*!\endcond */
+/*!\cond */
+typedef struct {
+ // Mask for each reference frame, specifying which prediction modes to NOT
+ // try during search.
+ uint32_t pred_modes[REF_FRAMES];
+ // If ref_combo[i][j + 1] is true, do NOT try prediction using combination
+ // of reference frames (i, j). Indexing with 'j + 1' is due to the fact that
+ // 2nd reference can be -1 (INVALID_FRAME). NOTE: In
+ // CONFIG_NEW_REF_SIGNALING, indexing for the reference has the order the
+ // INTER references followed by INTRA
+ bool ref_combo[REF_FRAMES][REF_FRAMES + 1];
+} mode_skip_mask_t;
+/*!\endcond */
#if CONFIG_NEW_REF_SIGNALING
- // Update 'ref_combo' mask to disable given 'ref' in single and compound
- // modes.
- static AOM_INLINE void disable_reference(
- MV_REFERENCE_FRAME ref, bool ref_combo[REF_FRAMES][REF_FRAMES + 1]) {
- for (MV_REFERENCE_FRAME ref2 = NONE_FRAME; ref2 < REF_FRAMES; ++ref2) {
- ref_combo[COMPACT_INDEX0_NRS(ref)][ref2 + 1] = true;
- }
+// Update 'ref_combo' mask to disable given 'ref' in single and compound
+// modes.
+static AOM_INLINE void disable_reference(
+ MV_REFERENCE_FRAME ref, bool ref_combo[REF_FRAMES][REF_FRAMES + 1]) {
+ for (MV_REFERENCE_FRAME ref2 = NONE_FRAME; ref2 < REF_FRAMES; ++ref2) {
+ ref_combo[COMPACT_INDEX0_NRS(ref)][ref2 + 1] = true;
}
+}
- // Disable rank 2 (indexed by 1) to rank 7 references.
- static AOM_INLINE void disable_inter_references_except_top(
- bool ref_combo[REF_FRAMES][REF_FRAMES + 1]) {
- for (MV_REFERENCE_FRAME ref = 1; ref < REF_FRAMES; ++ref)
- disable_reference(ref, ref_combo);
- }
+// Disable rank 2 (indexed by 1) to rank 7 references.
+static AOM_INLINE void disable_inter_references_except_top(
+ bool ref_combo[REF_FRAMES][REF_FRAMES + 1]) {
+ for (MV_REFERENCE_FRAME ref = 1; ref < REF_FRAMES; ++ref)
+ disable_reference(ref, ref_combo);
+}
- // Define single and compound reference combinations allowed in
- // "enable_reduced_reference_set" speed feature.
- static const MV_REFERENCE_FRAME reduced_ref_combos[][2] = {
- { 0, NONE_FRAME }, { 1, NONE_FRAME }, { 2, NONE_FRAME },
- { 3, NONE_FRAME }, { 4, NONE_FRAME }, { INTRA_FRAME, NONE_FRAME },
- { 0, INTRA_FRAME }, { 1, INTRA_FRAME }, { 2, INTRA_FRAME },
- { 3, INTRA_FRAME }, { 0, 1 }, { 0, 2 },
- { 0, 3 }, { 1, 2 }, { 1, 3 },
- { 2, 3 },
- };
+// Define single and compound reference combinations allowed in
+// "enable_reduced_reference_set" speed feature.
+static const MV_REFERENCE_FRAME reduced_ref_combos[][2] = {
+ { 0, NONE_FRAME }, { 1, NONE_FRAME }, { 2, NONE_FRAME },
+ { 3, NONE_FRAME }, { 4, NONE_FRAME }, { INTRA_FRAME, NONE_FRAME },
+ { 0, INTRA_FRAME }, { 1, INTRA_FRAME }, { 2, INTRA_FRAME },
+ { 3, INTRA_FRAME }, { 0, 1 }, { 0, 2 },
+ { 0, 3 }, { 1, 2 }, { 1, 3 },
+ { 2, 3 },
+};
#else
// Update 'ref_combo' mask to disable given 'ref' in single and compound modes.
static AOM_INLINE void disable_reference(
@@ -5953,230 +5557,228 @@
};
#endif // CONFIG_NEW_REF_SIGNALING
- typedef enum { REF_SET_FULL, REF_SET_REDUCED } REF_SET;
+typedef enum { REF_SET_FULL, REF_SET_REDUCED } REF_SET;
- static AOM_INLINE void default_skip_mask(mode_skip_mask_t * mask,
- REF_SET ref_set) {
- if (ref_set == REF_SET_FULL) {
- // Everything available by default.
- memset(mask, 0, sizeof(*mask));
- } else {
- // All modes available by default.
- memset(mask->pred_modes, 0, sizeof(mask->pred_modes));
- // All references disabled first.
- bool *mask_ref_combo = &mask->ref_combo[0][0];
- for (int k = 0; k < REF_FRAMES * (REF_FRAMES + 1); k++)
- mask_ref_combo[k] = true;
+static AOM_INLINE void default_skip_mask(mode_skip_mask_t *mask,
+ REF_SET ref_set) {
+ if (ref_set == REF_SET_FULL) {
+ // Everything available by default.
+ memset(mask, 0, sizeof(*mask));
+ } else {
+ // All modes available by default.
+ memset(mask->pred_modes, 0, sizeof(mask->pred_modes));
+ // All references disabled first.
+ bool *mask_ref_combo = &mask->ref_combo[0][0];
+ for (int k = 0; k < REF_FRAMES * (REF_FRAMES + 1); k++)
+ mask_ref_combo[k] = true;
- const MV_REFERENCE_FRAME(*ref_set_combos)[2];
- int num_ref_combos;
+ const MV_REFERENCE_FRAME(*ref_set_combos)[2];
+ int num_ref_combos;
- // Then enable reduced set of references explicitly.
- switch (ref_set) {
- case REF_SET_REDUCED:
- ref_set_combos = reduced_ref_combos;
- num_ref_combos =
- (int)sizeof(reduced_ref_combos) / sizeof(reduced_ref_combos[0]);
- break;
- default: assert(0); num_ref_combos = 0;
- }
+ // Then enable reduced set of references explicitly.
+ switch (ref_set) {
+ case REF_SET_REDUCED:
+ ref_set_combos = reduced_ref_combos;
+ num_ref_combos =
+ (int)sizeof(reduced_ref_combos) / sizeof(reduced_ref_combos[0]);
+ break;
+ default: assert(0); num_ref_combos = 0;
+ }
- for (int i = 0; i < num_ref_combos; ++i) {
- const MV_REFERENCE_FRAME *const this_combo = ref_set_combos[i];
+ for (int i = 0; i < num_ref_combos; ++i) {
+ const MV_REFERENCE_FRAME *const this_combo = ref_set_combos[i];
#if CONFIG_NEW_REF_SIGNALING
- mask->ref_combo[COMPACT_INDEX0_NRS(this_combo[0])]
- [COMPACT_INDEX0_NRS(this_combo[1]) + 1] = false;
+ mask->ref_combo[COMPACT_INDEX0_NRS(this_combo[0])]
+ [COMPACT_INDEX0_NRS(this_combo[1]) + 1] = false;
#else
mask->ref_combo[this_combo[0]][this_combo[1] + 1] = false;
#endif // CONFIG_NEW_REF_SIGNALING
- }
}
}
+}
- static AOM_INLINE void init_mode_skip_mask(mode_skip_mask_t * mask,
- const AV1_COMP *cpi, MACROBLOCK *x,
- BLOCK_SIZE bsize) {
- const AV1_COMMON *const cm = &cpi->common;
+static AOM_INLINE void init_mode_skip_mask(mode_skip_mask_t *mask,
+ const AV1_COMP *cpi, MACROBLOCK *x,
+ BLOCK_SIZE bsize) {
+ const AV1_COMMON *const cm = &cpi->common;
#if !CONFIG_NEW_REF_SIGNALING
- const struct segmentation *const seg = &cm->seg;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- unsigned char segment_id = mbmi->segment_id;
+ const struct segmentation *const seg = &cm->seg;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ unsigned char segment_id = mbmi->segment_id;
#endif // !CONFIG_NEW_REF_SIGNALING
- const SPEED_FEATURES *const sf = &cpi->sf;
- REF_SET ref_set = REF_SET_FULL;
+ const SPEED_FEATURES *const sf = &cpi->sf;
+ REF_SET ref_set = REF_SET_FULL;
- if (cpi->oxcf.ref_frm_cfg.enable_reduced_reference_set)
- ref_set = REF_SET_REDUCED;
+ if (cpi->oxcf.ref_frm_cfg.enable_reduced_reference_set)
+ ref_set = REF_SET_REDUCED;
- default_skip_mask(mask, ref_set);
+ default_skip_mask(mask, ref_set);
- int min_pred_mv_sad = INT_MAX;
- MV_REFERENCE_FRAME ref_frame;
+ int min_pred_mv_sad = INT_MAX;
+ MV_REFERENCE_FRAME ref_frame;
#if CONFIG_NEW_REF_SIGNALING
- for (ref_frame = 0; ref_frame < cm->ref_frames_info.num_total_refs;
- ++ref_frame)
+ for (ref_frame = 0; ref_frame < cm->ref_frames_info.num_total_refs;
+ ++ref_frame)
#else
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame)
#endif // CONFIG_NEW_REF_SIGNALING
- min_pred_mv_sad = AOMMIN(min_pred_mv_sad, x->pred_mv_sad[ref_frame]);
+ min_pred_mv_sad = AOMMIN(min_pred_mv_sad, x->pred_mv_sad[ref_frame]);
#if CONFIG_TIP
- min_pred_mv_sad = AOMMIN(min_pred_mv_sad, x->pred_mv_sad[TIP_FRAME_INDEX]);
+ min_pred_mv_sad = AOMMIN(min_pred_mv_sad, x->pred_mv_sad[TIP_FRAME_INDEX]);
#endif // CONFIG_TIP
#if CONFIG_NEW_REF_SIGNALING
- for (ref_frame = 0; ref_frame < cm->ref_frames_info.num_total_refs;
- ++ref_frame) {
- if (!(cm->ref_frame_flags & (1 << ref_frame))) {
+ for (ref_frame = 0; ref_frame < cm->ref_frames_info.num_total_refs;
+ ++ref_frame) {
+ if (!(cm->ref_frame_flags & (1 << ref_frame))) {
#else
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
if (!(cm->ref_frame_flags & av1_ref_frame_flag_list[ref_frame])) {
#endif // CONFIG_NEW_REF_SIGNALING
// Skip checking missing reference in both single and compound reference
// modes.
- disable_reference(ref_frame, mask->ref_combo);
- } else {
- // Skip fixed mv modes for poor references
- if ((x->pred_mv_sad[ref_frame] >> 2) > min_pred_mv_sad) {
- mask->pred_modes[ref_frame] |= INTER_NEAR_GLOBAL;
- }
- }
-#if !CONFIG_NEW_REF_SIGNALING
- if (segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) &&
- get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame) {
- // Reference not used for the segment.
- disable_reference(ref_frame, mask->ref_combo);
- }
-#endif // !CONFIG_NEW_REF_SIGNALING
- }
-
-#if !CONFIG_NEW_REF_SIGNALING
- // Note: We use the following drop-out only if the SEG_LVL_REF_FRAME feature
- // is disabled for this segment. This is to prevent the possibility that we
- // end up unable to pick any mode.
- if (!segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) {
- // Only consider GLOBALMV/ALTREF_FRAME for alt ref frame,
- // unless ARNR filtering is enabled in which case we want
- // an unfiltered alternative. We allow near/nearest as well
- // because they may result in zero-zero MVs but be cheaper.
- if (cpi->rc.is_src_frame_alt_ref &&
- (cpi->oxcf.algo_cfg.arnr_max_frames == 0)) {
- disable_inter_references_except_altref(mask->ref_combo);
-
- mask->pred_modes[ALTREF_FRAME] = ~INTER_NEAR_GLOBAL;
- const MV_REFERENCE_FRAME tmp_ref_frames[2] = { ALTREF_FRAME,
- NONE_FRAME };
- int_mv near_mv, global_mv;
- get_this_mv(&near_mv, NEARMV, 0, 0, 0, tmp_ref_frames, x->mbmi_ext);
- get_this_mv(&global_mv, GLOBALMV, 0, 0, 0, tmp_ref_frames, x->mbmi_ext);
- if (near_mv.as_int != global_mv.as_int)
- mask->pred_modes[ALTREF_FRAME] |= (1 << NEARMV);
+ disable_reference(ref_frame, mask->ref_combo);
+ } else {
+ // Skip fixed mv modes for poor references
+ if ((x->pred_mv_sad[ref_frame] >> 2) > min_pred_mv_sad) {
+ mask->pred_modes[ref_frame] |= INTER_NEAR_GLOBAL;
}
}
+#if !CONFIG_NEW_REF_SIGNALING
+ if (segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) &&
+ get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame) {
+ // Reference not used for the segment.
+ disable_reference(ref_frame, mask->ref_combo);
+ }
+#endif // !CONFIG_NEW_REF_SIGNALING
+ }
+
+#if !CONFIG_NEW_REF_SIGNALING
+ // Note: We use the following drop-out only if the SEG_LVL_REF_FRAME feature
+ // is disabled for this segment. This is to prevent the possibility that we
+ // end up unable to pick any mode.
+ if (!segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) {
+ // Only consider GLOBALMV/ALTREF_FRAME for alt ref frame,
+ // unless ARNR filtering is enabled in which case we want
+ // an unfiltered alternative. We allow near/nearest as well
+ // because they may result in zero-zero MVs but be cheaper.
+ if (cpi->rc.is_src_frame_alt_ref &&
+ (cpi->oxcf.algo_cfg.arnr_max_frames == 0)) {
+ disable_inter_references_except_altref(mask->ref_combo);
+
+ mask->pred_modes[ALTREF_FRAME] = ~INTER_NEAR_GLOBAL;
+ const MV_REFERENCE_FRAME tmp_ref_frames[2] = { ALTREF_FRAME, NONE_FRAME };
+ int_mv near_mv, global_mv;
+ get_this_mv(&near_mv, NEARMV, 0, 0, 0, tmp_ref_frames, x->mbmi_ext);
+ get_this_mv(&global_mv, GLOBALMV, 0, 0, 0, tmp_ref_frames, x->mbmi_ext);
+ if (near_mv.as_int != global_mv.as_int)
+ mask->pred_modes[ALTREF_FRAME] |= (1 << NEARMV);
+ }
+ }
#endif // !CONFIG_NEW_REF_SIGNALING
- if (cpi->rc.is_src_frame_alt_ref) {
- if (sf->inter_sf.alt_ref_search_fp) {
+ if (cpi->rc.is_src_frame_alt_ref) {
+ if (sf->inter_sf.alt_ref_search_fp) {
#if CONFIG_NEW_REF_SIGNALING
- mask->pred_modes[0] = 0;
- disable_inter_references_except_top(mask->ref_combo);
+ mask->pred_modes[0] = 0;
+ disable_inter_references_except_top(mask->ref_combo);
#else
assert(cm->ref_frame_flags & av1_ref_frame_flag_list[ALTREF_FRAME]);
mask->pred_modes[ALTREF_FRAME] = 0;
disable_inter_references_except_altref(mask->ref_combo);
#endif // CONFIG_NEW_REF_SIGNALING
- disable_reference(INTRA_FRAME, mask->ref_combo);
- }
+ disable_reference(INTRA_FRAME, mask->ref_combo);
}
+ }
- if (sf->inter_sf.alt_ref_search_fp) {
- if (!cm->show_frame && x->best_pred_mv_sad < INT_MAX) {
- int sad_thresh = x->best_pred_mv_sad + (x->best_pred_mv_sad >> 3);
- // Conservatively skip the modes w.r.t. BWDREF, ALTREF2 and ALTREF, if
- // those are past frames
+ if (sf->inter_sf.alt_ref_search_fp) {
+ if (!cm->show_frame && x->best_pred_mv_sad < INT_MAX) {
+ int sad_thresh = x->best_pred_mv_sad + (x->best_pred_mv_sad >> 3);
+ // Conservatively skip the modes w.r.t. BWDREF, ALTREF2 and ALTREF, if
+ // those are past frames
#if CONFIG_NEW_REF_SIGNALING
- for (ref_frame = 4; ref_frame < INTER_REFS_PER_FRAME; ref_frame++) {
- if (cpi->ref_frame_dist_info.ref_relative_dist[ref_frame] < 0)
+ for (ref_frame = 4; ref_frame < INTER_REFS_PER_FRAME; ref_frame++) {
+ if (cpi->ref_frame_dist_info.ref_relative_dist[ref_frame] < 0)
#else
for (ref_frame = BWDREF_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) {
if (cpi->ref_frame_dist_info.ref_relative_dist[ref_frame - LAST_FRAME] <
0)
#endif // CONFIG_NEW_REF_SIGNALING
- if (x->pred_mv_sad[ref_frame] > sad_thresh)
- mask->pred_modes[ref_frame] |= INTER_ALL;
- }
+ if (x->pred_mv_sad[ref_frame] > sad_thresh)
+ mask->pred_modes[ref_frame] |= INTER_ALL;
}
}
+ }
- if (bsize > sf->part_sf.max_intra_bsize) {
- disable_reference(INTRA_FRAME, mask->ref_combo);
- }
+ if (bsize > sf->part_sf.max_intra_bsize) {
+ disable_reference(INTRA_FRAME, mask->ref_combo);
+ }
#if CONFIG_NEW_REF_SIGNALING
- mask->pred_modes[INTRA_FRAME_INDEX] |=
+ mask->pred_modes[INTRA_FRAME_INDEX] |=
#else
mask->pred_modes[INTRA_FRAME] |=
#endif // CONFIG_NEW_REF_SIGNALING
- ~(sf->intra_sf.intra_y_mode_mask[max_txsize_lookup[bsize]]);
- }
+ ~(sf->intra_sf.intra_y_mode_mask[max_txsize_lookup[bsize]]);
+}
- static AOM_INLINE void init_neighbor_pred_buf(
- const OBMCBuffer *const obmc_buffer, HandleInterModeArgs *const args,
- int is_hbd) {
- if (is_hbd) {
- const int len = sizeof(uint16_t);
- args->above_pred_buf[0] = CONVERT_TO_BYTEPTR(obmc_buffer->above_pred);
- args->above_pred_buf[1] = CONVERT_TO_BYTEPTR(obmc_buffer->above_pred +
- (MAX_SB_SQUARE >> 1) * len);
- args->above_pred_buf[2] =
- CONVERT_TO_BYTEPTR(obmc_buffer->above_pred + MAX_SB_SQUARE * len);
- args->left_pred_buf[0] = CONVERT_TO_BYTEPTR(obmc_buffer->left_pred);
- args->left_pred_buf[1] = CONVERT_TO_BYTEPTR(obmc_buffer->left_pred +
- (MAX_SB_SQUARE >> 1) * len);
- args->left_pred_buf[2] =
- CONVERT_TO_BYTEPTR(obmc_buffer->left_pred + MAX_SB_SQUARE * len);
- } else {
- args->above_pred_buf[0] = obmc_buffer->above_pred;
- args->above_pred_buf[1] = obmc_buffer->above_pred + (MAX_SB_SQUARE >> 1);
- args->above_pred_buf[2] = obmc_buffer->above_pred + MAX_SB_SQUARE;
- args->left_pred_buf[0] = obmc_buffer->left_pred;
- args->left_pred_buf[1] = obmc_buffer->left_pred + (MAX_SB_SQUARE >> 1);
- args->left_pred_buf[2] = obmc_buffer->left_pred + MAX_SB_SQUARE;
- }
+static AOM_INLINE void init_neighbor_pred_buf(
+ const OBMCBuffer *const obmc_buffer, HandleInterModeArgs *const args,
+ int is_hbd) {
+ if (is_hbd) {
+ const int len = sizeof(uint16_t);
+ args->above_pred_buf[0] = CONVERT_TO_BYTEPTR(obmc_buffer->above_pred);
+ args->above_pred_buf[1] = CONVERT_TO_BYTEPTR(obmc_buffer->above_pred +
+ (MAX_SB_SQUARE >> 1) * len);
+ args->above_pred_buf[2] =
+ CONVERT_TO_BYTEPTR(obmc_buffer->above_pred + MAX_SB_SQUARE * len);
+ args->left_pred_buf[0] = CONVERT_TO_BYTEPTR(obmc_buffer->left_pred);
+ args->left_pred_buf[1] =
+ CONVERT_TO_BYTEPTR(obmc_buffer->left_pred + (MAX_SB_SQUARE >> 1) * len);
+ args->left_pred_buf[2] =
+ CONVERT_TO_BYTEPTR(obmc_buffer->left_pred + MAX_SB_SQUARE * len);
+ } else {
+ args->above_pred_buf[0] = obmc_buffer->above_pred;
+ args->above_pred_buf[1] = obmc_buffer->above_pred + (MAX_SB_SQUARE >> 1);
+ args->above_pred_buf[2] = obmc_buffer->above_pred + MAX_SB_SQUARE;
+ args->left_pred_buf[0] = obmc_buffer->left_pred;
+ args->left_pred_buf[1] = obmc_buffer->left_pred + (MAX_SB_SQUARE >> 1);
+ args->left_pred_buf[2] = obmc_buffer->left_pred + MAX_SB_SQUARE;
}
+}
#if CONFIG_NEW_REF_SIGNALING
- static AOM_INLINE int prune_ref_frame(const AV1_COMP *cpi,
- const MACROBLOCK *x,
- const MV_REFERENCE_FRAME ref_frame) {
- const AV1_COMMON *const cm = &cpi->common;
- MV_REFERENCE_FRAME rf[2];
- av1_set_ref_frame(rf, ref_frame);
- const int comp_pred = is_inter_ref_frame(rf[1]);
- if (comp_pred) {
- if (!cpi->oxcf.ref_frm_cfg.enable_onesided_comp ||
- cpi->sf.inter_sf.disable_onesided_comp) {
- // Disable all compound references
- if (cpi->all_one_sided_refs) return 1;
- // If both references are on the same side prune
- if (get_dir_rank(cm, rf[0], NULL) == get_dir_rank(cm, rf[1], NULL))
- return 1;
- } else if (cpi->sf.inter_sf.selective_ref_frame >= 2) {
- // One sided compound is used only when all reference frames are
- // one-sided.
- if (!cpi->all_one_sided_refs &&
- get_dir_rank(cm, rf[0], NULL) == get_dir_rank(cm, rf[1], NULL))
- return 1;
- }
+static AOM_INLINE int prune_ref_frame(const AV1_COMP *cpi, const MACROBLOCK *x,
+ const MV_REFERENCE_FRAME ref_frame) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, ref_frame);
+ const int comp_pred = is_inter_ref_frame(rf[1]);
+ if (comp_pred) {
+ if (!cpi->oxcf.ref_frm_cfg.enable_onesided_comp ||
+ cpi->sf.inter_sf.disable_onesided_comp) {
+ // Disable all compound references
+ if (cpi->all_one_sided_refs) return 1;
+ // If both references are on the same side prune
+ if (get_dir_rank(cm, rf[0], NULL) == get_dir_rank(cm, rf[1], NULL))
+ return 1;
+ } else if (cpi->sf.inter_sf.selective_ref_frame >= 2) {
+ // One sided compound is used only when all reference frames are
+ // one-sided.
+ if (!cpi->all_one_sided_refs &&
+ get_dir_rank(cm, rf[0], NULL) == get_dir_rank(cm, rf[1], NULL))
+ return 1;
}
-
- if (prune_ref_by_selective_ref_frame(cpi, x, rf)) {
- return 1;
- }
-
- return 0;
}
+
+ if (prune_ref_by_selective_ref_frame(cpi, x, rf)) {
+ return 1;
+ }
+
+ return 0;
+}
#else
static AOM_INLINE int prune_ref_frame(const AV1_COMP *cpi, const MACROBLOCK *x,
MV_REFERENCE_FRAME ref_frame) {
@@ -6195,13 +5797,13 @@
}
#endif // CONFIG_NEW_REF_SIGNALING
- static AOM_INLINE int is_ref_frame_used_by_compound_ref(
- int ref_frame, int skip_ref_frame_mask) {
+static AOM_INLINE int is_ref_frame_used_by_compound_ref(
+ int ref_frame, int skip_ref_frame_mask) {
#if CONFIG_NEW_REF_SIGNALING
- for (int r = INTER_REFS_PER_FRAME; r < INTRA_FRAME; ++r) {
- if (!(skip_ref_frame_mask & (1 << r))) {
- MV_REFERENCE_FRAME rf[2];
- av1_set_ref_frame(rf, r);
+ for (int r = INTER_REFS_PER_FRAME; r < INTRA_FRAME; ++r) {
+ if (!(skip_ref_frame_mask & (1 << r))) {
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, r);
#else
#if CONFIG_TIP
for (int r = ALTREF_FRAME + 1; r < MODE_CTX_REF_FRAMES - 1; ++r) {
@@ -6211,43 +5813,42 @@
if (!(skip_ref_frame_mask & (1 << r))) {
const MV_REFERENCE_FRAME *rf = ref_frame_map[r - REF_FRAMES];
#endif // CONFIG_NEW_REF_SIGNALING
- if (rf[0] == ref_frame || rf[1] == ref_frame) {
- return 1;
- }
+ if (rf[0] == ref_frame || rf[1] == ref_frame) {
+ return 1;
}
}
- return 0;
}
+ return 0;
+}
- // Please add/modify parameter setting in this function, making it consistent
- // and easy to read and maintain.
- static AOM_INLINE void set_params_rd_pick_inter_mode(
- const AV1_COMP *cpi, MACROBLOCK *x, HandleInterModeArgs *args,
- BLOCK_SIZE bsize, mode_skip_mask_t *mode_skip_mask,
- int skip_ref_frame_mask, unsigned int *ref_costs_single,
- unsigned int(*ref_costs_comp)[REF_FRAMES],
- struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE]) {
- const AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
- unsigned char segment_id = mbmi->segment_id;
+// Please add/modify parameter setting in this function, making it consistent
+// and easy to read and maintain.
+static AOM_INLINE void set_params_rd_pick_inter_mode(
+ const AV1_COMP *cpi, MACROBLOCK *x, HandleInterModeArgs *args,
+ BLOCK_SIZE bsize, mode_skip_mask_t *mode_skip_mask, int skip_ref_frame_mask,
+ unsigned int *ref_costs_single, unsigned int (*ref_costs_comp)[REF_FRAMES],
+ struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE]) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
+ unsigned char segment_id = mbmi->segment_id;
- init_neighbor_pred_buf(&x->obmc_buffer, args, is_cur_buf_hbd(&x->e_mbd));
- av1_collect_neighbors_ref_counts(xd);
- estimate_ref_frame_costs(cm, xd, &x->mode_costs, segment_id,
- ref_costs_single, ref_costs_comp);
+ init_neighbor_pred_buf(&x->obmc_buffer, args, is_cur_buf_hbd(&x->e_mbd));
+ av1_collect_neighbors_ref_counts(xd);
+ estimate_ref_frame_costs(cm, xd, &x->mode_costs, segment_id, ref_costs_single,
+ ref_costs_comp);
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
- x->best_pred_mv_sad = INT_MAX;
- MV_REFERENCE_FRAME ref_frame;
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
+ x->best_pred_mv_sad = INT_MAX;
+ MV_REFERENCE_FRAME ref_frame;
#if CONFIG_NEW_REF_SIGNALING
- for (ref_frame = 0; ref_frame < INTER_REFS_PER_FRAME; ++ref_frame) {
- x->mbmi_ext->mode_context[ref_frame] = 0;
- mbmi_ext->ref_mv_count[ref_frame] = UINT8_MAX;
- if ((cm->ref_frame_flags & (1 << ref_frame))) {
- x->pred_mv_sad[ref_frame] = INT_MAX;
+ for (ref_frame = 0; ref_frame < INTER_REFS_PER_FRAME; ++ref_frame) {
+ x->mbmi_ext->mode_context[ref_frame] = 0;
+ mbmi_ext->ref_mv_count[ref_frame] = UINT8_MAX;
+ if ((cm->ref_frame_flags & (1 << ref_frame))) {
+ x->pred_mv_sad[ref_frame] = INT_MAX;
#else
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
x->pred_mv_sad[ref_frame] = INT_MAX;
@@ -6255,53 +5856,51 @@
mbmi_ext->ref_mv_count[ref_frame] = UINT8_MAX;
if (cm->ref_frame_flags & av1_ref_frame_flag_list[ref_frame]) {
#endif // CONFIG_NEW_REF_SIGNALING
- if (mbmi->partition != PARTITION_NONE &&
- mbmi->partition != PARTITION_SPLIT) {
- if (skip_ref_frame_mask & (1 << ref_frame) &&
- !is_ref_frame_used_by_compound_ref(ref_frame,
- skip_ref_frame_mask))
- continue;
- }
- assert(get_ref_frame_yv12_buf(cm, ref_frame) != NULL);
- setup_buffer_ref_mvs_inter(cpi, x, ref_frame, bsize, yv12_mb);
+ if (mbmi->partition != PARTITION_NONE &&
+ mbmi->partition != PARTITION_SPLIT) {
+ if (skip_ref_frame_mask & (1 << ref_frame) &&
+ !is_ref_frame_used_by_compound_ref(ref_frame, skip_ref_frame_mask))
+ continue;
}
-#if !CONFIG_NEW_REF_SIGNALING
- // Store the best pred_mv_sad across all past frames
- if (cpi->sf.inter_sf.alt_ref_search_fp &&
- cpi->ref_frame_dist_info.ref_relative_dist[ref_frame - LAST_FRAME] <
- 0)
- x->best_pred_mv_sad =
- AOMMIN(x->best_pred_mv_sad, x->pred_mv_sad[ref_frame]);
-#endif // !CONFIG_NEW_REF_SIGNALING
+ assert(get_ref_frame_yv12_buf(cm, ref_frame) != NULL);
+ setup_buffer_ref_mvs_inter(cpi, x, ref_frame, bsize, yv12_mb);
}
+#if !CONFIG_NEW_REF_SIGNALING
+ // Store the best pred_mv_sad across all past frames
+ if (cpi->sf.inter_sf.alt_ref_search_fp &&
+ cpi->ref_frame_dist_info.ref_relative_dist[ref_frame - LAST_FRAME] < 0)
+ x->best_pred_mv_sad =
+ AOMMIN(x->best_pred_mv_sad, x->pred_mv_sad[ref_frame]);
+#endif // !CONFIG_NEW_REF_SIGNALING
+ }
#if CONFIG_TIP
- x->mbmi_ext->mode_context[TIP_FRAME] = 0;
- mbmi_ext->ref_mv_count[TIP_FRAME] = UINT8_MAX;
- x->pred_mv_sad[TIP_FRAME_INDEX] = INT_MAX;
- assert(get_ref_frame_yv12_buf(cm, TIP_FRAME) != NULL);
- setup_buffer_ref_mvs_inter(cpi, x, TIP_FRAME, bsize, yv12_mb);
+ x->mbmi_ext->mode_context[TIP_FRAME] = 0;
+ mbmi_ext->ref_mv_count[TIP_FRAME] = UINT8_MAX;
+ x->pred_mv_sad[TIP_FRAME_INDEX] = INT_MAX;
+ assert(get_ref_frame_yv12_buf(cm, TIP_FRAME) != NULL);
+ setup_buffer_ref_mvs_inter(cpi, x, TIP_FRAME, bsize, yv12_mb);
#endif // CONFIG_TIP
- if (is_comp_ref_allowed(bsize)) {
- // No second reference on RT ref set, so no need to initialize
+ if (is_comp_ref_allowed(bsize)) {
+ // No second reference on RT ref set, so no need to initialize
#if CONFIG_TIP
- for (; ref_frame < MODE_CTX_REF_FRAMES - 1; ++ref_frame) {
+ for (; ref_frame < MODE_CTX_REF_FRAMES - 1; ++ref_frame) {
#else
for (; ref_frame < MODE_CTX_REF_FRAMES; ++ref_frame) {
#endif // CONFIG_TIP
- x->mbmi_ext->mode_context[ref_frame] = 0;
- mbmi_ext->ref_mv_count[ref_frame] = UINT8_MAX;
+ x->mbmi_ext->mode_context[ref_frame] = 0;
+ mbmi_ext->ref_mv_count[ref_frame] = UINT8_MAX;
#if CONFIG_NEW_REF_SIGNALING
- MV_REFERENCE_FRAME rf[2];
- av1_set_ref_frame(rf, ref_frame);
- if (rf[0] >= cm->ref_frames_info.num_total_refs ||
- rf[1] >= cm->ref_frames_info.num_total_refs)
- continue;
- if (!((cm->ref_frame_flags & (1 << rf[0])) &&
- (cm->ref_frame_flags & (1 << rf[1])))) {
- continue;
- }
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, ref_frame);
+ if (rf[0] >= cm->ref_frames_info.num_total_refs ||
+ rf[1] >= cm->ref_frames_info.num_total_refs)
+ continue;
+ if (!((cm->ref_frame_flags & (1 << rf[0])) &&
+ (cm->ref_frame_flags & (1 << rf[1])))) {
+ continue;
+ }
#else
const MV_REFERENCE_FRAME *rf = ref_frame_map[ref_frame - REF_FRAMES];
if (!((cm->ref_frame_flags & av1_ref_frame_flag_list[rf[0]]) &&
@@ -6310,120 +5909,117 @@
}
#endif // CONFIG_NEW_REF_SIGNALING
- if (mbmi->partition != PARTITION_NONE &&
- mbmi->partition != PARTITION_SPLIT) {
- if (skip_ref_frame_mask & (1 << ref_frame)) {
- continue;
- }
+ if (mbmi->partition != PARTITION_NONE &&
+ mbmi->partition != PARTITION_SPLIT) {
+ if (skip_ref_frame_mask & (1 << ref_frame)) {
+ continue;
}
- // Ref mv list population is not required, when compound references are
- // pruned.
- if (prune_ref_frame(cpi, x, ref_frame)) continue;
-
- av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
- xd->ref_mv_stack, xd->weight, NULL,
- mbmi_ext->global_mvs, mbmi_ext->mode_context);
- // TODO(Ravi): Populate mbmi_ext->ref_mv_stack[ref_frame][4] and
- // mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
- av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame);
}
- }
+ // Ref mv list population is not required, when compound references are
+ // pruned.
+ if (prune_ref_frame(cpi, x, ref_frame)) continue;
- av1_count_overlappable_neighbors(cm, xd);
- const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group);
- const int prune_obmc = cpi->frame_probs.obmc_probs[update_type][bsize] <
- cpi->sf.inter_sf.prune_obmc_prob_thresh;
- if (cpi->oxcf.motion_mode_cfg.enable_obmc &&
- !cpi->sf.inter_sf.disable_obmc &&
+ av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
+ xd->ref_mv_stack, xd->weight, NULL, mbmi_ext->global_mvs,
+ mbmi_ext->mode_context);
+ // TODO(Ravi): Populate mbmi_ext->ref_mv_stack[ref_frame][4] and
+ // mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
+ av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame);
+ }
+ }
+
+ av1_count_overlappable_neighbors(cm, xd);
+ const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group);
+ const int prune_obmc = cpi->frame_probs.obmc_probs[update_type][bsize] <
+ cpi->sf.inter_sf.prune_obmc_prob_thresh;
+ if (cpi->oxcf.motion_mode_cfg.enable_obmc && !cpi->sf.inter_sf.disable_obmc &&
#if CONFIG_TIP
- !is_tip_ref_frame(mbmi->ref_frame[0]) &&
+ !is_tip_ref_frame(mbmi->ref_frame[0]) &&
#endif // CONFIG_TIP
- !prune_obmc) {
- if (check_num_overlappable_neighbors(mbmi) &&
- is_motion_variation_allowed_bsize(bsize)) {
- int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE,
- MAX_SB_SIZE };
- int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
- MAX_SB_SIZE >> 1 };
- int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
- MAX_SB_SIZE >> 1 };
- int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE,
- MAX_SB_SIZE };
- av1_build_prediction_by_above_preds(cm, xd, args->above_pred_buf,
- dst_width1, dst_height1,
- args->above_pred_stride);
- av1_build_prediction_by_left_preds(cm, xd, args->left_pred_buf,
- dst_width2, dst_height2,
- args->left_pred_stride);
- const int num_planes = av1_num_planes(cm);
- av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row,
- mi_col, 0, num_planes);
- calc_target_weighted_pred(
- cm, x, xd, args->above_pred_buf[0], args->above_pred_stride[0],
- args->left_pred_buf[0], args->left_pred_stride[0]);
- }
+ !prune_obmc) {
+ if (check_num_overlappable_neighbors(mbmi) &&
+ is_motion_variation_allowed_bsize(bsize)) {
+ int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
+ int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
+ MAX_SB_SIZE >> 1 };
+ int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
+ MAX_SB_SIZE >> 1 };
+ int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
+ av1_build_prediction_by_above_preds(cm, xd, args->above_pred_buf,
+ dst_width1, dst_height1,
+ args->above_pred_stride);
+ av1_build_prediction_by_left_preds(cm, xd, args->left_pred_buf,
+ dst_width2, dst_height2,
+ args->left_pred_stride);
+ const int num_planes = av1_num_planes(cm);
+ av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row,
+ mi_col, 0, num_planes);
+ calc_target_weighted_pred(
+ cm, x, xd, args->above_pred_buf[0], args->above_pred_stride[0],
+ args->left_pred_buf[0], args->left_pred_stride[0]);
}
-
- init_mode_skip_mask(mode_skip_mask, cpi, x, bsize);
-
- // Set params for mode evaluation
- set_mode_eval_params(cpi, x, MODE_EVAL);
-
- x->comp_rd_stats_idx = 0;
}
- static AOM_INLINE void init_intra_mode_search_state(IntraModeSearchState *
- intra_search_state) {
- intra_search_state->skip_intra_modes = 0;
- intra_search_state->best_intra_mode = DC_PRED;
- intra_search_state->best_mrl_index = 0;
+ init_mode_skip_mask(mode_skip_mask, cpi, x, bsize);
+
+ // Set params for mode evaluation
+ set_mode_eval_params(cpi, x, MODE_EVAL);
+
+ x->comp_rd_stats_idx = 0;
+}
+
+static AOM_INLINE void init_intra_mode_search_state(
+ IntraModeSearchState *intra_search_state) {
+ intra_search_state->skip_intra_modes = 0;
+ intra_search_state->best_intra_mode = DC_PRED;
+ intra_search_state->best_mrl_index = 0;
#if CONFIG_FORWARDSKIP
- intra_search_state->best_fsc = 0;
+ intra_search_state->best_fsc = 0;
#endif // CONFIG_FORWARDSKIP
- intra_search_state->dir_mode_skip_mask_ready = 0;
- av1_zero(intra_search_state->directional_mode_skip_mask);
- intra_search_state->rate_uv_intra = INT_MAX;
- av1_zero(intra_search_state->pmi_uv);
- for (int i = 0; i < REFERENCE_MODES; ++i)
- intra_search_state->best_pred_rd[i] = INT64_MAX;
- }
+ intra_search_state->dir_mode_skip_mask_ready = 0;
+ av1_zero(intra_search_state->directional_mode_skip_mask);
+ intra_search_state->rate_uv_intra = INT_MAX;
+ av1_zero(intra_search_state->pmi_uv);
+ for (int i = 0; i < REFERENCE_MODES; ++i)
+ intra_search_state->best_pred_rd[i] = INT64_MAX;
+}
- static AOM_INLINE void init_inter_mode_search_state(
- InterModeSearchState * search_state, const AV1_COMP *cpi,
- const MACROBLOCK *x, BLOCK_SIZE bsize, int64_t best_rd_so_far) {
- init_intra_mode_search_state(&search_state->intra_search_state);
+static AOM_INLINE void init_inter_mode_search_state(
+ InterModeSearchState *search_state, const AV1_COMP *cpi,
+ const MACROBLOCK *x, BLOCK_SIZE bsize, int64_t best_rd_so_far) {
+ init_intra_mode_search_state(&search_state->intra_search_state);
- search_state->best_rd = best_rd_so_far;
- search_state->best_skip_rd[0] = INT64_MAX;
- search_state->best_skip_rd[1] = INT64_MAX;
+ search_state->best_rd = best_rd_so_far;
+ search_state->best_skip_rd[0] = INT64_MAX;
+ search_state->best_skip_rd[1] = INT64_MAX;
- av1_zero(search_state->best_mbmode);
+ av1_zero(search_state->best_mbmode);
- search_state->best_mbmode.mode = MODE_INVALID;
+ search_state->best_mbmode.mode = MODE_INVALID;
- search_state->best_rate_y = INT_MAX;
+ search_state->best_rate_y = INT_MAX;
- search_state->best_rate_uv = INT_MAX;
+ search_state->best_rate_uv = INT_MAX;
- search_state->best_mode_skippable = 0;
+ search_state->best_mode_skippable = 0;
- search_state->best_skip2 = 0;
+ search_state->best_skip2 = 0;
- const MACROBLOCKD *const xd = &x->e_mbd;
- const MB_MODE_INFO *const mbmi = xd->mi[0];
- const unsigned char segment_id = mbmi->segment_id;
+ const MACROBLOCKD *const xd = &x->e_mbd;
+ const MB_MODE_INFO *const mbmi = xd->mi[0];
+ const unsigned char segment_id = mbmi->segment_id;
- search_state->num_available_refs = 0;
- memset(search_state->dist_refs, -1, sizeof(search_state->dist_refs));
- memset(search_state->dist_order_refs, -1,
- sizeof(search_state->dist_order_refs));
+ search_state->num_available_refs = 0;
+ memset(search_state->dist_refs, -1, sizeof(search_state->dist_refs));
+ memset(search_state->dist_order_refs, -1,
+ sizeof(search_state->dist_order_refs));
#if CONFIG_NEW_REF_SIGNALING
- const int *const rd_threshes = cpi->rd.threshes[segment_id][bsize];
- for (int i = 0; i < MB_MODE_COUNT; ++i)
- search_state->mode_threshold[i] =
- ((int64_t)rd_threshes[i] * x->thresh_freq_fact[bsize][i]) >>
- RD_THRESH_FAC_FRAC_BITS;
+ const int *const rd_threshes = cpi->rd.threshes[segment_id][bsize];
+ for (int i = 0; i < MB_MODE_COUNT; ++i)
+ search_state->mode_threshold[i] =
+ ((int64_t)rd_threshes[i] * x->thresh_freq_fact[bsize][i]) >>
+ RD_THRESH_FAC_FRAC_BITS;
#else
for (int i = 0; i <= LAST_NEW_MV_INDEX; ++i)
search_state->mode_threshold[i] = 0;
@@ -6434,106 +6030,107 @@
RD_THRESH_FAC_FRAC_BITS;
#endif // CONFIG_NEW_REF_SIGNALING
- search_state->best_intra_rd = INT64_MAX;
+ search_state->best_intra_rd = INT64_MAX;
- search_state->best_pred_sse = UINT_MAX;
+ search_state->best_pred_sse = UINT_MAX;
- av1_zero(search_state->single_newmv);
- av1_zero(search_state->single_newmv_rate);
- av1_zero(search_state->single_newmv_valid);
- for (int i = 0; i < MB_MODE_COUNT; ++i) {
- for (int j = 0; j < MAX_REF_MV_SEARCH; ++j) {
- for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
- search_state->modelled_rd[i][j][ref_frame] = INT64_MAX;
- search_state->simple_rd[i][j][ref_frame] = INT64_MAX;
- }
+ av1_zero(search_state->single_newmv);
+ av1_zero(search_state->single_newmv_rate);
+ av1_zero(search_state->single_newmv_valid);
+ for (int i = 0; i < MB_MODE_COUNT; ++i) {
+ for (int j = 0; j < MAX_REF_MV_SEARCH; ++j) {
+ for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
+ search_state->modelled_rd[i][j][ref_frame] = INT64_MAX;
+ search_state->simple_rd[i][j][ref_frame] = INT64_MAX;
}
}
-
- for (int dir = 0; dir < 2; ++dir) {
- for (int mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
-#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
-#else
- for (int ref_frame = 0; ref_frame < FWD_REFS; ++ref_frame) {
-#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- SingleInterModeState *state;
-
- state = &search_state->single_state[dir][mode][ref_frame];
- state->ref_frame = NONE_FRAME;
- state->rd = INT64_MAX;
-
- state = &search_state->single_state_modelled[dir][mode][ref_frame];
- state->ref_frame = NONE_FRAME;
- state->rd = INT64_MAX;
- }
- }
- }
- for (int dir = 0; dir < 2; ++dir) {
- for (int mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
-#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
-#else
- for (int ref_frame = 0; ref_frame < FWD_REFS; ++ref_frame) {
-#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- search_state->single_rd_order[dir][mode][ref_frame] = NONE_FRAME;
- }
- }
- }
-
- for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
- search_state->best_single_rd[ref_frame] = INT64_MAX;
- search_state->best_single_mode[ref_frame] = MB_MODE_COUNT;
- }
- av1_zero(search_state->single_state_cnt);
- av1_zero(search_state->single_state_modelled_cnt);
}
- static bool mask_says_skip(const mode_skip_mask_t *mode_skip_mask,
- const MV_REFERENCE_FRAME *ref_frame,
- const PREDICTION_MODE this_mode) {
+ for (int dir = 0; dir < 2; ++dir) {
+ for (int mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
+#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
+ for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
+#else
+ for (int ref_frame = 0; ref_frame < FWD_REFS; ++ref_frame) {
+#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
+ SingleInterModeState *state;
+
+ state = &search_state->single_state[dir][mode][ref_frame];
+ state->ref_frame = NONE_FRAME;
+ state->rd = INT64_MAX;
+
+ state = &search_state->single_state_modelled[dir][mode][ref_frame];
+ state->ref_frame = NONE_FRAME;
+ state->rd = INT64_MAX;
+ }
+ }
+ }
+ for (int dir = 0; dir < 2; ++dir) {
+ for (int mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
+#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
+ for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
+#else
+ for (int ref_frame = 0; ref_frame < FWD_REFS; ++ref_frame) {
+#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
+ search_state->single_rd_order[dir][mode][ref_frame] = NONE_FRAME;
+ }
+ }
+ }
+
+ for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
+ search_state->best_single_rd[ref_frame] = INT64_MAX;
+ search_state->best_single_mode[ref_frame] = MB_MODE_COUNT;
+ }
+ av1_zero(search_state->single_state_cnt);
+ av1_zero(search_state->single_state_modelled_cnt);
+}
+
+static bool mask_says_skip(const mode_skip_mask_t *mode_skip_mask,
+ const MV_REFERENCE_FRAME *ref_frame,
+ const PREDICTION_MODE this_mode) {
#if CONFIG_TIP
- if (is_tip_ref_frame(ref_frame[0])) return false;
+ if (is_tip_ref_frame(ref_frame[0])) return false;
#endif // CONFIG_TIP
#if CONFIG_NEW_REF_SIGNALING
- if (mode_skip_mask->pred_modes[COMPACT_INDEX0_NRS(ref_frame[0])] &
- (1 << this_mode)) {
+ if (mode_skip_mask->pred_modes[COMPACT_INDEX0_NRS(ref_frame[0])] &
+ (1 << this_mode)) {
#else
if (mode_skip_mask->pred_modes[ref_frame[0]] & (1 << this_mode)) {
#endif // CONFIG_NEW_REF_SIGNALING
- return true;
- }
+ return true;
+ }
#if CONFIG_NEW_REF_SIGNALING
- return mode_skip_mask->ref_combo[COMPACT_INDEX0_NRS(ref_frame[0])]
- [COMPACT_INDEX0_NRS(ref_frame[1]) + 1];
+ return mode_skip_mask->ref_combo[COMPACT_INDEX0_NRS(ref_frame[0])]
+ [COMPACT_INDEX0_NRS(ref_frame[1]) + 1];
#else
return mode_skip_mask->ref_combo[ref_frame[0]][ref_frame[1] + 1];
#endif // CONFIG_NEW_REF_SIGNALING
- }
+}
- static int inter_mode_compatible_skip(
- const AV1_COMP *cpi, const MACROBLOCK *x, BLOCK_SIZE bsize,
- PREDICTION_MODE curr_mode, const MV_REFERENCE_FRAME *ref_frames) {
- const int comp_pred = is_inter_ref_frame(ref_frames[1]);
- if (comp_pred) {
- if (!is_comp_ref_allowed(bsize)) return 1;
+static int inter_mode_compatible_skip(const AV1_COMP *cpi, const MACROBLOCK *x,
+ BLOCK_SIZE bsize,
+ PREDICTION_MODE curr_mode,
+ const MV_REFERENCE_FRAME *ref_frames) {
+ const int comp_pred = is_inter_ref_frame(ref_frames[1]);
+ if (comp_pred) {
+ if (!is_comp_ref_allowed(bsize)) return 1;
#if CONFIG_NEW_REF_SIGNALING
- if (!(cpi->common.ref_frame_flags & (1 << ref_frames[1])))
+ if (!(cpi->common.ref_frame_flags & (1 << ref_frames[1])))
#else
if (!(cpi->common.ref_frame_flags & av1_ref_frame_flag_list[ref_frames[1]]))
#endif // CONFIG_NEW_REF_SIGNALING
- return 1;
+ return 1;
- const AV1_COMMON *const cm = &cpi->common;
- if (frame_is_intra_only(cm)) return 1;
+ const AV1_COMMON *const cm = &cpi->common;
+ if (frame_is_intra_only(cm)) return 1;
- const CurrentFrame *const current_frame = &cm->current_frame;
- if (current_frame->reference_mode == SINGLE_REFERENCE) return 1;
+ const CurrentFrame *const current_frame = &cm->current_frame;
+ if (current_frame->reference_mode == SINGLE_REFERENCE) return 1;
#if CONFIG_NEW_REF_SIGNALING
- (void)x;
+ (void)x;
#else
const struct segmentation *const seg = &cm->seg;
const unsigned char segment_id = x->e_mbd.mi[0]->segment_id;
@@ -6541,83 +6138,81 @@
// feature is in use as in this case there can only be one reference.
if (segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) return 1;
#endif // CONFIG_NEW_REF_SIGNALING
- }
+ }
- if (is_inter_ref_frame(ref_frames[0]) && ref_frames[1] == INTRA_FRAME) {
- // Mode must be compatible
- if (!is_interintra_allowed_bsize(bsize)) return 1;
- if (!is_interintra_allowed_mode(curr_mode)) return 1;
- }
+ if (is_inter_ref_frame(ref_frames[0]) && ref_frames[1] == INTRA_FRAME) {
+ // Mode must be compatible
+ if (!is_interintra_allowed_bsize(bsize)) return 1;
+ if (!is_interintra_allowed_mode(curr_mode)) return 1;
+ }
+ return 0;
+}
+
+static int fetch_picked_ref_frames_mask(const MACROBLOCK *const x,
+ BLOCK_SIZE bsize, int mib_size) {
+ const int sb_size_mask = mib_size - 1;
+ const MACROBLOCKD *const xd = &x->e_mbd;
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
+ const int mi_row_in_sb = mi_row & sb_size_mask;
+ const int mi_col_in_sb = mi_col & sb_size_mask;
+ const int mi_w = mi_size_wide[bsize];
+ const int mi_h = mi_size_high[bsize];
+ int picked_ref_frames_mask = 0;
+ for (int i = mi_row_in_sb; i < mi_row_in_sb + mi_h; ++i) {
+ for (int j = mi_col_in_sb; j < mi_col_in_sb + mi_w; ++j) {
+ picked_ref_frames_mask |= x->picked_ref_frames_mask[i * 32 + j];
+ }
+ }
+ return picked_ref_frames_mask;
+}
+
+// Case 1: return 0, means don't skip this mode
+// Case 2: return 1, means skip this mode completely
+// Case 3: return 2, means skip compound only, but still try single motion
+// modes
+static int inter_mode_search_order_independent_skip(
+ const AV1_COMP *cpi, const MACROBLOCK *x, mode_skip_mask_t *mode_skip_mask,
+ InterModeSearchState *search_state, int skip_ref_frame_mask,
+ PREDICTION_MODE mode, const MV_REFERENCE_FRAME *ref_frame) {
+ if (mask_says_skip(mode_skip_mask, ref_frame, mode)) {
+ return 1;
+ }
+
+ const int ref_type = av1_ref_frame_type(ref_frame);
+ if (prune_ref_frame(cpi, x, ref_type)) return 1;
+
+ // This is only used in motion vector unit test.
+ if (cpi->oxcf.unit_test_cfg.motion_vector_unit_test &&
+ ref_frame[0] == INTRA_FRAME)
+ return 1;
+
+ const AV1_COMMON *const cm = &cpi->common;
+ if (skip_repeated_mv(cm, x, mode, ref_frame, search_state)) {
+ return 1;
+ }
+
+ const MB_MODE_INFO *const mbmi = x->e_mbd.mi[0];
+ // If no valid mode has been found so far in PARTITION_NONE when finding a
+ // valid partition is required, do not skip mode.
+ if (search_state->best_rd == INT64_MAX && mbmi->partition == PARTITION_NONE &&
+ x->must_find_valid_partition)
return 0;
- }
- static int fetch_picked_ref_frames_mask(const MACROBLOCK *const x,
- BLOCK_SIZE bsize, int mib_size) {
- const int sb_size_mask = mib_size - 1;
- const MACROBLOCKD *const xd = &x->e_mbd;
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
- const int mi_row_in_sb = mi_row & sb_size_mask;
- const int mi_col_in_sb = mi_col & sb_size_mask;
- const int mi_w = mi_size_wide[bsize];
- const int mi_h = mi_size_high[bsize];
- int picked_ref_frames_mask = 0;
- for (int i = mi_row_in_sb; i < mi_row_in_sb + mi_h; ++i) {
- for (int j = mi_col_in_sb; j < mi_col_in_sb + mi_w; ++j) {
- picked_ref_frames_mask |= x->picked_ref_frames_mask[i * 32 + j];
- }
- }
- return picked_ref_frames_mask;
- }
-
- // Case 1: return 0, means don't skip this mode
- // Case 2: return 1, means skip this mode completely
- // Case 3: return 2, means skip compound only, but still try single motion
- // modes
- static int inter_mode_search_order_independent_skip(
- const AV1_COMP *cpi, const MACROBLOCK *x,
- mode_skip_mask_t *mode_skip_mask, InterModeSearchState *search_state,
- int skip_ref_frame_mask, PREDICTION_MODE mode,
- const MV_REFERENCE_FRAME *ref_frame) {
- if (mask_says_skip(mode_skip_mask, ref_frame, mode)) {
- return 1;
- }
-
- const int ref_type = av1_ref_frame_type(ref_frame);
- if (prune_ref_frame(cpi, x, ref_type)) return 1;
-
- // This is only used in motion vector unit test.
- if (cpi->oxcf.unit_test_cfg.motion_vector_unit_test &&
- ref_frame[0] == INTRA_FRAME)
- return 1;
-
- const AV1_COMMON *const cm = &cpi->common;
- if (skip_repeated_mv(cm, x, mode, ref_frame, search_state)) {
- return 1;
- }
-
- const MB_MODE_INFO *const mbmi = x->e_mbd.mi[0];
- // If no valid mode has been found so far in PARTITION_NONE when finding a
- // valid partition is required, do not skip mode.
- if (search_state->best_rd == INT64_MAX &&
- mbmi->partition == PARTITION_NONE && x->must_find_valid_partition)
- return 0;
-
- int skip_motion_mode = 0;
- if (mbmi->partition != PARTITION_NONE &&
- mbmi->partition != PARTITION_SPLIT) {
- int skip_ref = skip_ref_frame_mask & (1 << ref_type);
+ int skip_motion_mode = 0;
+ if (mbmi->partition != PARTITION_NONE && mbmi->partition != PARTITION_SPLIT) {
+ int skip_ref = skip_ref_frame_mask & (1 << ref_type);
#if CONFIG_NEW_REF_SIGNALING
- if (ref_type < INTER_REFS_PER_FRAME && skip_ref) {
- // Since the compound ref modes depends on the motion estimation result
- // of two single ref modes( best mv of single ref modes as the start
- // point ) If current single ref mode is marked skip, we need to check
- // if it will be used in compound ref modes.
- for (int r = INTER_REFS_PER_FRAME; r < INTRA_FRAME; ++r) {
- if (skip_ref_frame_mask & (1 << r)) continue;
- MV_REFERENCE_FRAME rf[2];
- av1_set_ref_frame(rf, r);
+ if (ref_type < INTER_REFS_PER_FRAME && skip_ref) {
+ // Since the compound ref modes depends on the motion estimation result
+ // of two single ref modes( best mv of single ref modes as the start
+ // point ) If current single ref mode is marked skip, we need to check
+ // if it will be used in compound ref modes.
+ for (int r = INTER_REFS_PER_FRAME; r < INTRA_FRAME; ++r) {
+ if (skip_ref_frame_mask & (1 << r)) continue;
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, r);
#else
if (ref_type <= ALTREF_FRAME && skip_ref) {
// Since the compound ref modes depends on the motion estimation result of
@@ -6632,79 +6227,80 @@
if (skip_ref_frame_mask & (1 << r)) continue;
const MV_REFERENCE_FRAME *rf = ref_frame_map[r - REF_FRAMES];
#endif // CONFIG_NEW_REF_SIGNALING
- if (rf[0] == ref_type || rf[1] == ref_type) {
- // Found a not skipped compound ref mode which contains current
- // single ref. So this single ref can't be skipped completly
- // Just skip it's motion mode search, still try it's simple
- // transition mode.
- skip_motion_mode = 1;
- skip_ref = 0;
- break;
- }
+ if (rf[0] == ref_type || rf[1] == ref_type) {
+ // Found a not skipped compound ref mode which contains current
+ // single ref. So this single ref can't be skipped completly
+ // Just skip it's motion mode search, still try it's simple
+ // transition mode.
+ skip_motion_mode = 1;
+ skip_ref = 0;
+ break;
}
}
- if (skip_ref) return 1;
}
-
- if (skip_motion_mode) return 2;
-
- return 0;
+ if (skip_ref) return 1;
}
- static INLINE void init_mbmi(MB_MODE_INFO * mbmi, PREDICTION_MODE curr_mode,
- const MV_REFERENCE_FRAME *ref_frames,
+ if (skip_motion_mode) return 2;
+
+ return 0;
+}
+
+static INLINE void init_mbmi(MB_MODE_INFO *mbmi, PREDICTION_MODE curr_mode,
+ const MV_REFERENCE_FRAME *ref_frames,
#if CONFIG_IBC_SR_EXT
- const AV1_COMMON *cm, MACROBLOCKD *const xd
+ const AV1_COMMON *cm, MACROBLOCKD *const xd
#else
const AV1_COMMON *cm
#endif // CONFIG_IBC_SR_EXT
#if CONFIG_FLEX_MVRES
- ,
- const SB_INFO *sbi
+ ,
+ const SB_INFO *sbi
#endif
- ) {
+) {
- PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
- mbmi->ref_mv_idx = 0;
- mbmi->mode = curr_mode;
- mbmi->uv_mode = UV_DC_PRED;
- mbmi->ref_frame[0] = ref_frames[0];
- mbmi->ref_frame[1] = ref_frames[1];
- pmi->palette_size[0] = 0;
- pmi->palette_size[1] = 0;
- mbmi->filter_intra_mode_info.use_filter_intra = 0;
- mbmi->mv[0].as_int = mbmi->mv[1].as_int = 0;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->interintra_mode = (INTERINTRA_MODE)(II_DC_PRED - 1);
- set_default_interp_filters(mbmi,
+ PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
+ mbmi->ref_mv_idx = 0;
+ mbmi->mode = curr_mode;
+ mbmi->uv_mode = UV_DC_PRED;
+ mbmi->ref_frame[0] = ref_frames[0];
+ mbmi->ref_frame[1] = ref_frames[1];
+ pmi->palette_size[0] = 0;
+ pmi->palette_size[1] = 0;
+ mbmi->filter_intra_mode_info.use_filter_intra = 0;
+ mbmi->mv[0].as_int = mbmi->mv[1].as_int = 0;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->interintra_mode = (INTERINTRA_MODE)(II_DC_PRED - 1);
+ set_default_interp_filters(mbmi,
#if CONFIG_OPTFLOW_REFINEMENT
- cm,
+ cm,
#endif // CONFIG_OPTFLOW_REFINEMENT
- cm->features.interp_filter);
+ cm->features.interp_filter);
#if CONFIG_IBC_SR_EXT
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
#endif // CONFIG_IBC_SR_EXT
#if CONFIG_FLEX_MVRES
- set_default_max_mv_precision(mbmi, sbi->sb_mv_precision);
- set_mv_precision(mbmi, mbmi->max_mv_precision);
+ set_default_max_mv_precision(mbmi, sbi->sb_mv_precision);
+ set_mv_precision(mbmi, mbmi->max_mv_precision);
#endif
#if CONFIG_DERIVED_MV
- mbmi->derived_mv_allowed = mbmi->use_derived_mv = 0;
+ mbmi->derived_mv_allowed = mbmi->use_derived_mv = 0;
#endif // CONFIG_DERIVED_MV
- }
+}
- static AOM_INLINE void collect_single_states(
- const AV1_COMMON *const cm, MACROBLOCK *x,
- InterModeSearchState *search_state, const MB_MODE_INFO *const mbmi) {
- const FeatureFlags *const features = &cm->features;
- (void)features;
- int i, j;
- const PREDICTION_MODE this_mode = mbmi->mode;
+static AOM_INLINE void collect_single_states(const AV1_COMMON *const cm,
+ MACROBLOCK *x,
+ InterModeSearchState *search_state,
+ const MB_MODE_INFO *const mbmi) {
+ const FeatureFlags *const features = &cm->features;
+ (void)features;
+ int i, j;
+ const PREDICTION_MODE this_mode = mbmi->mode;
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- const MV_REFERENCE_FRAME ref_frame = COMPACT_INDEX0_NRS(mbmi->ref_frame[0]);
+ const MV_REFERENCE_FRAME ref_frame = COMPACT_INDEX0_NRS(mbmi->ref_frame[0]);
#if CONFIG_NEW_REF_SIGNALING
- const int dir = get_dir_rank(cm, mbmi->ref_frame[0], NULL);
+ const int dir = get_dir_rank(cm, mbmi->ref_frame[0], NULL);
#else
const int dir = ref_frame <= GOLDEN_FRAME ? 0 : 1;
#endif // CONFIG_NEW_REF_SIGNALING
@@ -6712,849 +6308,842 @@
const MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame[0];
const int dir = ref_frame <= GOLDEN_FRAME ? 0 : 1;
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- const int mode_offset = INTER_OFFSET(this_mode);
- const int ref_set = get_drl_refmv_count(features->max_drl_bits, x,
- mbmi->ref_frame, this_mode);
+ const int mode_offset = INTER_OFFSET(this_mode);
+ const int ref_set = get_drl_refmv_count(features->max_drl_bits, x,
+ mbmi->ref_frame, this_mode);
- // Simple rd
- int64_t simple_rd = search_state->simple_rd[this_mode][0][ref_frame];
- for (int ref_mv_idx = 1; ref_mv_idx < ref_set; ++ref_mv_idx) {
- const int64_t rd =
- search_state->simple_rd[this_mode][ref_mv_idx][ref_frame];
- if (rd < simple_rd) simple_rd = rd;
- }
-
- // Insertion sort of single_state
- const SingleInterModeState this_state_s = { simple_rd, ref_frame, 1 };
- SingleInterModeState *state_s =
- search_state->single_state[dir][mode_offset];
- i = search_state->single_state_cnt[dir][mode_offset];
- for (j = i; j > 0 && state_s[j - 1].rd > this_state_s.rd; --j)
- state_s[j] = state_s[j - 1];
- state_s[j] = this_state_s;
- search_state->single_state_cnt[dir][mode_offset]++;
-
- // Modelled rd
- int64_t modelled_rd = search_state->modelled_rd[this_mode][0][ref_frame];
- for (int ref_mv_idx = 1; ref_mv_idx < ref_set; ++ref_mv_idx) {
- const int64_t rd =
- search_state->modelled_rd[this_mode][ref_mv_idx][ref_frame];
- if (rd < modelled_rd) modelled_rd = rd;
- }
-
- // Insertion sort of single_state_modelled
- const SingleInterModeState this_state_m = { modelled_rd, ref_frame, 1 };
- SingleInterModeState *state_m =
- search_state->single_state_modelled[dir][mode_offset];
- i = search_state->single_state_modelled_cnt[dir][mode_offset];
- for (j = i; j > 0 && state_m[j - 1].rd > this_state_m.rd; --j)
- state_m[j] = state_m[j - 1];
- state_m[j] = this_state_m;
- search_state->single_state_modelled_cnt[dir][mode_offset]++;
+ // Simple rd
+ int64_t simple_rd = search_state->simple_rd[this_mode][0][ref_frame];
+ for (int ref_mv_idx = 1; ref_mv_idx < ref_set; ++ref_mv_idx) {
+ const int64_t rd =
+ search_state->simple_rd[this_mode][ref_mv_idx][ref_frame];
+ if (rd < simple_rd) simple_rd = rd;
}
- static AOM_INLINE void analyze_single_states(
- const AV1_COMP *cpi, InterModeSearchState *search_state) {
- const int prune_level = cpi->sf.inter_sf.prune_comp_search_by_single_result;
- assert(prune_level >= 1);
- int i, j, dir, mode;
+ // Insertion sort of single_state
+ const SingleInterModeState this_state_s = { simple_rd, ref_frame, 1 };
+ SingleInterModeState *state_s = search_state->single_state[dir][mode_offset];
+ i = search_state->single_state_cnt[dir][mode_offset];
+ for (j = i; j > 0 && state_s[j - 1].rd > this_state_s.rd; --j)
+ state_s[j] = state_s[j - 1];
+ state_s[j] = this_state_s;
+ search_state->single_state_cnt[dir][mode_offset]++;
- for (dir = 0; dir < 2; ++dir) {
- int64_t best_rd;
+ // Modelled rd
+ int64_t modelled_rd = search_state->modelled_rd[this_mode][0][ref_frame];
+ for (int ref_mv_idx = 1; ref_mv_idx < ref_set; ++ref_mv_idx) {
+ const int64_t rd =
+ search_state->modelled_rd[this_mode][ref_mv_idx][ref_frame];
+ if (rd < modelled_rd) modelled_rd = rd;
+ }
+
+ // Insertion sort of single_state_modelled
+ const SingleInterModeState this_state_m = { modelled_rd, ref_frame, 1 };
+ SingleInterModeState *state_m =
+ search_state->single_state_modelled[dir][mode_offset];
+ i = search_state->single_state_modelled_cnt[dir][mode_offset];
+ for (j = i; j > 0 && state_m[j - 1].rd > this_state_m.rd; --j)
+ state_m[j] = state_m[j - 1];
+ state_m[j] = this_state_m;
+ search_state->single_state_modelled_cnt[dir][mode_offset]++;
+}
+
+static AOM_INLINE void analyze_single_states(
+ const AV1_COMP *cpi, InterModeSearchState *search_state) {
+ const int prune_level = cpi->sf.inter_sf.prune_comp_search_by_single_result;
+ assert(prune_level >= 1);
+ int i, j, dir, mode;
+
+ for (dir = 0; dir < 2; ++dir) {
+ int64_t best_rd;
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- SingleInterModeState(*state)[SINGLE_REF_FRAMES];
+ SingleInterModeState(*state)[SINGLE_REF_FRAMES];
#else
SingleInterModeState(*state)[FWD_REFS];
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- const int prune_factor = prune_level >= 2 ? 6 : 5;
+ const int prune_factor = prune_level >= 2 ? 6 : 5;
- // Use the best rd of GLOBALMV or NEWMV to prune the unlikely reference
- // frames for all the modes (NEARMV may not have same motion vectors).
- // Always keep the best of each mode because it might form the best
- // possible combination with other mode.
- state = search_state->single_state[dir];
- best_rd = AOMMIN(state[INTER_OFFSET(NEWMV)][0].rd,
- state[INTER_OFFSET(GLOBALMV)][0].rd);
- for (mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
- for (i = 1; i < search_state->single_state_cnt[dir][mode]; ++i) {
- if (state[mode][i].rd != INT64_MAX &&
- (state[mode][i].rd >> 3) * prune_factor > best_rd) {
- state[mode][i].valid = 0;
- }
- }
- }
-
- state = search_state->single_state_modelled[dir];
- best_rd = AOMMIN(state[INTER_OFFSET(NEWMV)][0].rd,
- state[INTER_OFFSET(GLOBALMV)][0].rd);
- for (mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
- for (i = 1; i < search_state->single_state_modelled_cnt[dir][mode];
- ++i) {
- if (state[mode][i].rd != INT64_MAX &&
- (state[mode][i].rd >> 3) * prune_factor > best_rd) {
- state[mode][i].valid = 0;
- }
+ // Use the best rd of GLOBALMV or NEWMV to prune the unlikely reference
+ // frames for all the modes (NEARMV may not have same motion vectors).
+ // Always keep the best of each mode because it might form the best
+ // possible combination with other mode.
+ state = search_state->single_state[dir];
+ best_rd = AOMMIN(state[INTER_OFFSET(NEWMV)][0].rd,
+ state[INTER_OFFSET(GLOBALMV)][0].rd);
+ for (mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
+ for (i = 1; i < search_state->single_state_cnt[dir][mode]; ++i) {
+ if (state[mode][i].rd != INT64_MAX &&
+ (state[mode][i].rd >> 3) * prune_factor > best_rd) {
+ state[mode][i].valid = 0;
}
}
}
- // Ordering by simple rd first, then by modelled rd
- for (dir = 0; dir < 2; ++dir) {
- for (mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
- const int state_cnt_s = search_state->single_state_cnt[dir][mode];
- const int state_cnt_m =
- search_state->single_state_modelled_cnt[dir][mode];
- SingleInterModeState *state_s = search_state->single_state[dir][mode];
- SingleInterModeState *state_m =
- search_state->single_state_modelled[dir][mode];
- int count = 0;
- const int max_candidates = AOMMAX(state_cnt_s, state_cnt_m);
- for (i = 0; i < state_cnt_s; ++i) {
- if (state_s[i].rd == INT64_MAX) break;
- if (state_s[i].valid) {
- search_state->single_rd_order[dir][mode][count++] =
- state_s[i].ref_frame;
- }
- }
- if (count >= max_candidates) continue;
-
- for (i = 0; i < state_cnt_m && count < max_candidates; ++i) {
- if (state_m[i].rd == INT64_MAX) break;
- if (!state_m[i].valid) continue;
- const int ref_frame = state_m[i].ref_frame;
- int match = 0;
- // Check if existing already
- for (j = 0; j < count; ++j) {
- if (search_state->single_rd_order[dir][mode][j] == ref_frame) {
- match = 1;
- break;
- }
- }
- if (match) continue;
- // Check if this ref_frame is removed in simple rd
- int valid = 1;
- for (j = 0; j < state_cnt_s; ++j) {
- if (ref_frame == state_s[j].ref_frame) {
- valid = state_s[j].valid;
- break;
- }
- }
- if (valid) {
- search_state->single_rd_order[dir][mode][count++] = ref_frame;
- }
+ state = search_state->single_state_modelled[dir];
+ best_rd = AOMMIN(state[INTER_OFFSET(NEWMV)][0].rd,
+ state[INTER_OFFSET(GLOBALMV)][0].rd);
+ for (mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
+ for (i = 1; i < search_state->single_state_modelled_cnt[dir][mode]; ++i) {
+ if (state[mode][i].rd != INT64_MAX &&
+ (state[mode][i].rd >> 3) * prune_factor > best_rd) {
+ state[mode][i].valid = 0;
}
}
}
}
- static int compound_skip_get_candidates(
- const AV1_COMP *cpi, const InterModeSearchState *search_state,
- const int dir, const PREDICTION_MODE mode) {
- const int mode_offset = INTER_OFFSET(mode);
- const SingleInterModeState *state =
- search_state->single_state[dir][mode_offset];
- const SingleInterModeState *state_modelled =
- search_state->single_state_modelled[dir][mode_offset];
+ // Ordering by simple rd first, then by modelled rd
+ for (dir = 0; dir < 2; ++dir) {
+ for (mode = 0; mode < SINGLE_INTER_MODE_NUM; ++mode) {
+ const int state_cnt_s = search_state->single_state_cnt[dir][mode];
+ const int state_cnt_m =
+ search_state->single_state_modelled_cnt[dir][mode];
+ SingleInterModeState *state_s = search_state->single_state[dir][mode];
+ SingleInterModeState *state_m =
+ search_state->single_state_modelled[dir][mode];
+ int count = 0;
+ const int max_candidates = AOMMAX(state_cnt_s, state_cnt_m);
+ for (i = 0; i < state_cnt_s; ++i) {
+ if (state_s[i].rd == INT64_MAX) break;
+ if (state_s[i].valid) {
+ search_state->single_rd_order[dir][mode][count++] =
+ state_s[i].ref_frame;
+ }
+ }
+ if (count >= max_candidates) continue;
- int max_candidates = 0;
+ for (i = 0; i < state_cnt_m && count < max_candidates; ++i) {
+ if (state_m[i].rd == INT64_MAX) break;
+ if (!state_m[i].valid) continue;
+ const int ref_frame = state_m[i].ref_frame;
+ int match = 0;
+ // Check if existing already
+ for (j = 0; j < count; ++j) {
+ if (search_state->single_rd_order[dir][mode][j] == ref_frame) {
+ match = 1;
+ break;
+ }
+ }
+ if (match) continue;
+ // Check if this ref_frame is removed in simple rd
+ int valid = 1;
+ for (j = 0; j < state_cnt_s; ++j) {
+ if (ref_frame == state_s[j].ref_frame) {
+ valid = state_s[j].valid;
+ break;
+ }
+ }
+ if (valid) {
+ search_state->single_rd_order[dir][mode][count++] = ref_frame;
+ }
+ }
+ }
+ }
+}
+
+static int compound_skip_get_candidates(
+ const AV1_COMP *cpi, const InterModeSearchState *search_state,
+ const int dir, const PREDICTION_MODE mode) {
+ const int mode_offset = INTER_OFFSET(mode);
+ const SingleInterModeState *state =
+ search_state->single_state[dir][mode_offset];
+ const SingleInterModeState *state_modelled =
+ search_state->single_state_modelled[dir][mode_offset];
+
+ int max_candidates = 0;
#if CONFIG_NEW_REF_SIGNALING
- for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
+ for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
#else
for (int i = 0; i < FWD_REFS; ++i) {
#endif // CONFIG_NEW_REF_SIGNALING
- if (search_state->single_rd_order[dir][mode_offset][i] == NONE_FRAME)
- break;
- max_candidates++;
- }
-
- int candidates = max_candidates;
- if (cpi->sf.inter_sf.prune_comp_search_by_single_result >= 2) {
- candidates = AOMMIN(2, max_candidates);
- }
- if (cpi->sf.inter_sf.prune_comp_search_by_single_result >= 3) {
- if (state[0].rd != INT64_MAX && state_modelled[0].rd != INT64_MAX &&
- state[0].ref_frame == state_modelled[0].ref_frame)
- candidates = 1;
- if (mode == NEARMV || mode == GLOBALMV) candidates = 1;
- }
-
- if (cpi->sf.inter_sf.prune_comp_search_by_single_result >= 4) {
- // Limit the number of candidates to 1 in each direction for compound
- // prediction
- candidates = AOMMIN(1, candidates);
- }
- return candidates;
+ if (search_state->single_rd_order[dir][mode_offset][i] == NONE_FRAME) break;
+ max_candidates++;
}
- static int compound_skip_by_single_states(
- const AV1_COMP *cpi, const InterModeSearchState *search_state,
- const PREDICTION_MODE this_mode, const MV_REFERENCE_FRAME ref_frame,
- const MV_REFERENCE_FRAME second_ref_frame, const MACROBLOCK *x) {
- const MV_REFERENCE_FRAME refs[2] = { ref_frame, second_ref_frame };
- const int mode[2] = { compound_ref0_mode(this_mode),
- compound_ref1_mode(this_mode) };
- const int mode_offset[2] = { INTER_OFFSET(mode[0]), INTER_OFFSET(mode[1]) };
+ int candidates = max_candidates;
+ if (cpi->sf.inter_sf.prune_comp_search_by_single_result >= 2) {
+ candidates = AOMMIN(2, max_candidates);
+ }
+ if (cpi->sf.inter_sf.prune_comp_search_by_single_result >= 3) {
+ if (state[0].rd != INT64_MAX && state_modelled[0].rd != INT64_MAX &&
+ state[0].ref_frame == state_modelled[0].ref_frame)
+ candidates = 1;
+ if (mode == NEARMV || mode == GLOBALMV) candidates = 1;
+ }
+
+ if (cpi->sf.inter_sf.prune_comp_search_by_single_result >= 4) {
+ // Limit the number of candidates to 1 in each direction for compound
+ // prediction
+ candidates = AOMMIN(1, candidates);
+ }
+ return candidates;
+}
+
+static int compound_skip_by_single_states(
+ const AV1_COMP *cpi, const InterModeSearchState *search_state,
+ const PREDICTION_MODE this_mode, const MV_REFERENCE_FRAME ref_frame,
+ const MV_REFERENCE_FRAME second_ref_frame, const MACROBLOCK *x) {
+ const MV_REFERENCE_FRAME refs[2] = { ref_frame, second_ref_frame };
+ const int mode[2] = { compound_ref0_mode(this_mode),
+ compound_ref1_mode(this_mode) };
+ const int mode_offset[2] = { INTER_OFFSET(mode[0]), INTER_OFFSET(mode[1]) };
#if CONFIG_NEW_REF_SIGNALING
- const int mode_dir[2] = { get_dir_rank(&cpi->common, refs[0], NULL),
- get_dir_rank(&cpi->common, refs[1], NULL) };
+ const int mode_dir[2] = { get_dir_rank(&cpi->common, refs[0], NULL),
+ get_dir_rank(&cpi->common, refs[1], NULL) };
#else
const int mode_dir[2] = { refs[0] <= GOLDEN_FRAME ? 0 : 1,
refs[1] <= GOLDEN_FRAME ? 0 : 1 };
#endif // CONFIG_NEW_REF_SIGNALING
- int ref_searched[2] = { 0, 0 };
- int ref_mv_match[2] = { 1, 1 };
- int i, j;
+ int ref_searched[2] = { 0, 0 };
+ int ref_mv_match[2] = { 1, 1 };
+ int i, j;
- for (i = 0; i < 2; ++i) {
- const SingleInterModeState *state =
- search_state->single_state[mode_dir[i]][mode_offset[i]];
- const int state_cnt =
- search_state->single_state_cnt[mode_dir[i]][mode_offset[i]];
- for (j = 0; j < state_cnt; ++j) {
- if (state[j].ref_frame == refs[i]) {
- ref_searched[i] = 1;
- break;
- }
+ for (i = 0; i < 2; ++i) {
+ const SingleInterModeState *state =
+ search_state->single_state[mode_dir[i]][mode_offset[i]];
+ const int state_cnt =
+ search_state->single_state_cnt[mode_dir[i]][mode_offset[i]];
+ for (j = 0; j < state_cnt; ++j) {
+ if (state[j].ref_frame == refs[i]) {
+ ref_searched[i] = 1;
+ break;
}
}
+ }
- const int ref_set = get_drl_refmv_count(cpi->common.features.max_drl_bits,
- x, refs, this_mode);
- for (i = 0; i < 2; ++i) {
- if (!ref_searched[i] || (mode[i] != NEARMV)) {
- continue;
- }
- const MV_REFERENCE_FRAME single_refs[2] = { refs[i], NONE_FRAME };
- for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ref_mv_idx++) {
- int_mv single_mv;
- int_mv comp_mv;
- get_this_mv(&single_mv, mode[i], 0, ref_mv_idx, 0, single_refs,
- x->mbmi_ext);
- get_this_mv(&comp_mv, this_mode, i, ref_mv_idx, 0, refs, x->mbmi_ext);
- if (single_mv.as_int != comp_mv.as_int) {
- ref_mv_match[i] = 0;
- break;
- }
+ const int ref_set = get_drl_refmv_count(cpi->common.features.max_drl_bits, x,
+ refs, this_mode);
+ for (i = 0; i < 2; ++i) {
+ if (!ref_searched[i] || (mode[i] != NEARMV)) {
+ continue;
+ }
+ const MV_REFERENCE_FRAME single_refs[2] = { refs[i], NONE_FRAME };
+ for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ref_mv_idx++) {
+ int_mv single_mv;
+ int_mv comp_mv;
+ get_this_mv(&single_mv, mode[i], 0, ref_mv_idx, 0, single_refs,
+ x->mbmi_ext);
+ get_this_mv(&comp_mv, this_mode, i, ref_mv_idx, 0, refs, x->mbmi_ext);
+ if (single_mv.as_int != comp_mv.as_int) {
+ ref_mv_match[i] = 0;
+ break;
}
}
+ }
- for (i = 0; i < 2; ++i) {
- if (!ref_searched[i] || !ref_mv_match[i]) continue;
- const int candidates =
- compound_skip_get_candidates(cpi, search_state, mode_dir[i], mode[i]);
- const MV_REFERENCE_FRAME *ref_order =
- search_state->single_rd_order[mode_dir[i]][mode_offset[i]];
- int match = 0;
- for (j = 0; j < candidates; ++j) {
- if (refs[i] == ref_order[j]) {
- match = 1;
- break;
- }
+ for (i = 0; i < 2; ++i) {
+ if (!ref_searched[i] || !ref_mv_match[i]) continue;
+ const int candidates =
+ compound_skip_get_candidates(cpi, search_state, mode_dir[i], mode[i]);
+ const MV_REFERENCE_FRAME *ref_order =
+ search_state->single_rd_order[mode_dir[i]][mode_offset[i]];
+ int match = 0;
+ for (j = 0; j < candidates; ++j) {
+ if (refs[i] == ref_order[j]) {
+ match = 1;
+ break;
}
- if (!match) return 1;
}
+ if (!match) return 1;
+ }
+ return 0;
+}
+
+// Check if ref frames of current block matches with given block.
+static INLINE void match_ref_frame(const MB_MODE_INFO *const mbmi,
+ const MV_REFERENCE_FRAME *ref_frames,
+ int *const is_ref_match) {
+ if (is_inter_block(mbmi, SHARED_PART)) {
+ is_ref_match[0] |= ref_frames[0] == mbmi->ref_frame[0];
+ is_ref_match[1] |= ref_frames[1] == mbmi->ref_frame[0];
+ if (has_second_ref(mbmi)) {
+ is_ref_match[0] |= ref_frames[0] == mbmi->ref_frame[1];
+ is_ref_match[1] |= ref_frames[1] == mbmi->ref_frame[1];
+ }
+ }
+}
+
+// Prune compound mode using ref frames of neighbor blocks.
+static INLINE int compound_skip_using_neighbor_refs(
+ MACROBLOCKD *const xd, const PREDICTION_MODE this_mode,
+ const MV_REFERENCE_FRAME *ref_frames, int prune_compound_using_neighbors) {
+ // Exclude non-extended compound modes from pruning
+ if (this_mode == NEAR_NEARMV || this_mode == NEW_NEWMV ||
+ this_mode == GLOBAL_GLOBALMV)
return 0;
- }
- // Check if ref frames of current block matches with given block.
- static INLINE void match_ref_frame(const MB_MODE_INFO *const mbmi,
- const MV_REFERENCE_FRAME *ref_frames,
- int *const is_ref_match) {
- if (is_inter_block(mbmi, SHARED_PART)) {
- is_ref_match[0] |= ref_frames[0] == mbmi->ref_frame[0];
- is_ref_match[1] |= ref_frames[1] == mbmi->ref_frame[0];
- if (has_second_ref(mbmi)) {
- is_ref_match[0] |= ref_frames[0] == mbmi->ref_frame[1];
- is_ref_match[1] |= ref_frames[1] == mbmi->ref_frame[1];
- }
- }
- }
+ int is_ref_match[2] = { 0 }; // 0 - match for forward refs
+ // 1 - match for backward refs
+ // Check if ref frames of this block matches with left neighbor.
+ if (xd->left_available)
+ match_ref_frame(xd->left_mbmi, ref_frames, is_ref_match);
- // Prune compound mode using ref frames of neighbor blocks.
- static INLINE int compound_skip_using_neighbor_refs(
- MACROBLOCKD *const xd, const PREDICTION_MODE this_mode,
- const MV_REFERENCE_FRAME *ref_frames,
- int prune_compound_using_neighbors) {
- // Exclude non-extended compound modes from pruning
- if (this_mode == NEAR_NEARMV || this_mode == NEW_NEWMV ||
- this_mode == GLOBAL_GLOBALMV)
- return 0;
+ // Check if ref frames of this block matches with above neighbor.
+ if (xd->up_available)
+ match_ref_frame(xd->above_mbmi, ref_frames, is_ref_match);
- int is_ref_match[2] = { 0 }; // 0 - match for forward refs
- // 1 - match for backward refs
- // Check if ref frames of this block matches with left neighbor.
- if (xd->left_available)
- match_ref_frame(xd->left_mbmi, ref_frames, is_ref_match);
+ // Combine ref frame match with neighbors in forward and backward refs.
+ const int track_ref_match = is_ref_match[0] + is_ref_match[1];
- // Check if ref frames of this block matches with above neighbor.
- if (xd->up_available)
- match_ref_frame(xd->above_mbmi, ref_frames, is_ref_match);
+ // Pruning based on ref frame match with neighbors.
+ if (track_ref_match >= prune_compound_using_neighbors) return 0;
+ return 1;
+}
- // Combine ref frame match with neighbors in forward and backward refs.
- const int track_ref_match = is_ref_match[0] + is_ref_match[1];
-
- // Pruning based on ref frame match with neighbors.
- if (track_ref_match >= prune_compound_using_neighbors) return 0;
- return 1;
- }
-
- // Update best single mode for the given reference frame based on simple rd.
- static INLINE void update_best_single_mode(
- InterModeSearchState * search_state, const PREDICTION_MODE this_mode,
- const MV_REFERENCE_FRAME ref_frame, int64_t this_rd) {
+// Update best single mode for the given reference frame based on simple rd.
+static INLINE void update_best_single_mode(InterModeSearchState *search_state,
+ const PREDICTION_MODE this_mode,
+ const MV_REFERENCE_FRAME ref_frame,
+ int64_t this_rd) {
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- const MV_REFERENCE_FRAME rf = COMPACT_INDEX0_NRS(ref_frame);
+ const MV_REFERENCE_FRAME rf = COMPACT_INDEX0_NRS(ref_frame);
#else
const MV_REFERENCE_FRAME rf = ref_frame;
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- if (this_rd < search_state->best_single_rd[rf]) {
- search_state->best_single_rd[rf] = this_rd;
- search_state->best_single_mode[rf] = this_mode;
- }
+ if (this_rd < search_state->best_single_rd[rf]) {
+ search_state->best_single_rd[rf] = this_rd;
+ search_state->best_single_mode[rf] = this_mode;
}
+}
- // Prune compound mode using best single mode for the same reference.
- static INLINE int skip_compound_using_best_single_mode_ref(
- const PREDICTION_MODE this_mode, const MV_REFERENCE_FRAME *ref_frames,
- const PREDICTION_MODE *best_single_mode,
- int prune_comp_using_best_single_mode_ref) {
- // Exclude non-extended compound modes from pruning
- if (this_mode == NEAR_NEARMV || this_mode == NEW_NEWMV ||
- this_mode == GLOBAL_GLOBALMV)
- return 0;
+// Prune compound mode using best single mode for the same reference.
+static INLINE int skip_compound_using_best_single_mode_ref(
+ const PREDICTION_MODE this_mode, const MV_REFERENCE_FRAME *ref_frames,
+ const PREDICTION_MODE *best_single_mode,
+ int prune_comp_using_best_single_mode_ref) {
+ // Exclude non-extended compound modes from pruning
+ if (this_mode == NEAR_NEARMV || this_mode == NEW_NEWMV ||
+ this_mode == GLOBAL_GLOBALMV)
+ return 0;
- const PREDICTION_MODE comp_mode_ref0 = compound_ref0_mode(this_mode);
- // Get ref frame direction corresponding to NEWMV
- // 0 - NEWMV corresponding to forward direction
- // 1 - NEWMV corresponding to backward direction
- const int newmv_dir = comp_mode_ref0 != NEWMV;
+ const PREDICTION_MODE comp_mode_ref0 = compound_ref0_mode(this_mode);
+ // Get ref frame direction corresponding to NEWMV
+ // 0 - NEWMV corresponding to forward direction
+ // 1 - NEWMV corresponding to backward direction
+ const int newmv_dir = comp_mode_ref0 != NEWMV;
- // Avoid pruning the compound mode when ref frame corresponding to NEWMV
- // have NEWMV as single mode winner. Example: For an extended-compound mode,
- // {mode, {fwd_frame, bwd_frame}} = {NEAR_NEWMV, {LAST_FRAME, ALTREF_FRAME}}
- // - Ref frame corresponding to NEWMV is ALTREF_FRAME
- // - Avoid pruning this mode, if best single mode corresponding to ref frame
- // ALTREF_FRAME is NEWMV
- const PREDICTION_MODE single_mode = best_single_mode[ref_frames[newmv_dir]];
- if (single_mode == NEWMV) return 0;
+ // Avoid pruning the compound mode when ref frame corresponding to NEWMV
+ // have NEWMV as single mode winner. Example: For an extended-compound mode,
+ // {mode, {fwd_frame, bwd_frame}} = {NEAR_NEWMV, {LAST_FRAME, ALTREF_FRAME}}
+ // - Ref frame corresponding to NEWMV is ALTREF_FRAME
+ // - Avoid pruning this mode, if best single mode corresponding to ref frame
+ // ALTREF_FRAME is NEWMV
+ const PREDICTION_MODE single_mode = best_single_mode[ref_frames[newmv_dir]];
+ if (single_mode == NEWMV) return 0;
- // Avoid pruning the compound mode when best single mode is not available
- if (prune_comp_using_best_single_mode_ref == 1)
- if (single_mode == MB_MODE_COUNT) return 0;
+ // Avoid pruning the compound mode when best single mode is not available
+ if (prune_comp_using_best_single_mode_ref == 1)
+ if (single_mode == MB_MODE_COUNT) return 0;
+ return 1;
+}
+
+static int compare_int64(const void *a, const void *b) {
+ int64_t a64 = *((int64_t *)a);
+ int64_t b64 = *((int64_t *)b);
+ if (a64 < b64) {
+ return -1;
+ } else if (a64 == b64) {
+ return 0;
+ } else {
return 1;
}
+}
- static int compare_int64(const void *a, const void *b) {
- int64_t a64 = *((int64_t *)a);
- int64_t b64 = *((int64_t *)b);
- if (a64 < b64) {
- return -1;
- } else if (a64 == b64) {
- return 0;
- } else {
- return 1;
- }
+static INLINE void update_search_state(
+ InterModeSearchState *search_state, RD_STATS *best_rd_stats_dst,
+ PICK_MODE_CONTEXT *ctx, const RD_STATS *new_best_rd_stats,
+ const RD_STATS *new_best_rd_stats_y, const RD_STATS *new_best_rd_stats_uv,
+ PREDICTION_MODE new_best_mode, const MACROBLOCK *x, int txfm_search_done) {
+ const MACROBLOCKD *xd = &x->e_mbd;
+ const MB_MODE_INFO *mbmi = xd->mi[0];
+ const int skip_ctx = av1_get_skip_txfm_context(xd);
+ const int mode_is_intra = (new_best_mode < INTRA_MODE_END);
+ const int skip_txfm =
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] && !mode_is_intra;
+ const TxfmSearchInfo *txfm_info = &x->txfm_search_info;
+
+ search_state->best_rd = new_best_rd_stats->rdcost;
+ *best_rd_stats_dst = *new_best_rd_stats;
+ search_state->best_mbmode = *mbmi;
+ search_state->best_skip2 = skip_txfm;
+ search_state->best_mode_skippable = new_best_rd_stats->skip_txfm;
+ // When !txfm_search_done, new_best_rd_stats won't provide correct rate_y
+ // and rate_uv because av1_txfm_search process is replaced by rd estimation.
+ // Therefore, we should avoid updating best_rate_y and best_rate_uv here.
+ // These two values will be updated when av1_txfm_search is called.
+ if (txfm_search_done) {
+ search_state->best_rate_y =
+ new_best_rd_stats_y->rate +
+ x->mode_costs.skip_txfm_cost[skip_ctx]
+ [new_best_rd_stats->skip_txfm || skip_txfm];
+ search_state->best_rate_uv = new_best_rd_stats_uv->rate;
}
+ memcpy(ctx->blk_skip, txfm_info->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
+ av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
+}
- static INLINE void update_search_state(
- InterModeSearchState * search_state, RD_STATS * best_rd_stats_dst,
- PICK_MODE_CONTEXT * ctx, const RD_STATS *new_best_rd_stats,
- const RD_STATS *new_best_rd_stats_y, const RD_STATS *new_best_rd_stats_uv,
- PREDICTION_MODE new_best_mode, const MACROBLOCK *x,
- int txfm_search_done) {
- const MACROBLOCKD *xd = &x->e_mbd;
- const MB_MODE_INFO *mbmi = xd->mi[0];
- const int skip_ctx = av1_get_skip_txfm_context(xd);
- const int mode_is_intra = (new_best_mode < INTRA_MODE_END);
- const int skip_txfm =
- mbmi->skip_txfm[xd->tree_type == CHROMA_PART] && !mode_is_intra;
- const TxfmSearchInfo *txfm_info = &x->txfm_search_info;
-
- search_state->best_rd = new_best_rd_stats->rdcost;
- *best_rd_stats_dst = *new_best_rd_stats;
- search_state->best_mbmode = *mbmi;
- search_state->best_skip2 = skip_txfm;
- search_state->best_mode_skippable = new_best_rd_stats->skip_txfm;
- // When !txfm_search_done, new_best_rd_stats won't provide correct rate_y
- // and rate_uv because av1_txfm_search process is replaced by rd estimation.
- // Therefore, we should avoid updating best_rate_y and best_rate_uv here.
- // These two values will be updated when av1_txfm_search is called.
- if (txfm_search_done) {
- search_state->best_rate_y =
- new_best_rd_stats_y->rate +
- x->mode_costs.skip_txfm_cost[skip_ctx][new_best_rd_stats->skip_txfm ||
- skip_txfm];
- search_state->best_rate_uv = new_best_rd_stats_uv->rate;
- }
- memcpy(ctx->blk_skip, txfm_info->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
- av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
- }
-
- // Find the best RD for a reference frame (among single reference modes)
- // and store +10% of it in the 0-th (or last for NRS) element in ref_frame_rd.
- static AOM_INLINE void find_top_ref(int64_t * ref_frame_rd) {
- int64_t ref_copy[REF_FRAMES - 1];
+// Find the best RD for a reference frame (among single reference modes)
+// and store +10% of it in the 0-th (or last for NRS) element in ref_frame_rd.
+static AOM_INLINE void find_top_ref(int64_t *ref_frame_rd) {
+ int64_t ref_copy[REF_FRAMES - 1];
#if CONFIG_NEW_REF_SIGNALING
- assert(ref_frame_rd[INTRA_FRAME_INDEX] == INT64_MAX);
- memcpy(ref_copy, ref_frame_rd, sizeof(ref_frame_rd[0]) * (REF_FRAMES - 1));
+ assert(ref_frame_rd[INTRA_FRAME_INDEX] == INT64_MAX);
+ memcpy(ref_copy, ref_frame_rd, sizeof(ref_frame_rd[0]) * (REF_FRAMES - 1));
#else
assert(ref_frame_rd[0] == INT64_MAX);
memcpy(ref_copy, ref_frame_rd + 1,
sizeof(ref_frame_rd[0]) * (REF_FRAMES - 1));
#endif // CONFIG_NEW_REF_SIGNALING
- qsort(ref_copy, REF_FRAMES - 1, sizeof(int64_t), compare_int64);
+ qsort(ref_copy, REF_FRAMES - 1, sizeof(int64_t), compare_int64);
#if CONFIG_TIP
- int64_t cutoff = AOMMIN(ref_copy[0], ref_frame_rd[TIP_FRAME_INDEX]);
+ int64_t cutoff = AOMMIN(ref_copy[0], ref_frame_rd[TIP_FRAME_INDEX]);
#else
int64_t cutoff = ref_copy[0];
#endif // CONFIG_TIP
- // The cut-off is within 10% of the best.
- if (cutoff != INT64_MAX) {
- assert(cutoff < INT64_MAX / 200);
- cutoff = (110 * cutoff) / 100;
- }
+ // The cut-off is within 10% of the best.
+ if (cutoff != INT64_MAX) {
+ assert(cutoff < INT64_MAX / 200);
+ cutoff = (110 * cutoff) / 100;
+ }
#if CONFIG_NEW_REF_SIGNALING
- ref_frame_rd[INTRA_FRAME_INDEX] = cutoff;
+ ref_frame_rd[INTRA_FRAME_INDEX] = cutoff;
#else
ref_frame_rd[0] = cutoff;
#endif // CONFIG_NEW_REF_SIGNALING
- }
+}
- // Check if either frame is within the cutoff.
- static INLINE bool in_single_ref_cutoff(int64_t * ref_frame_rd,
- MV_REFERENCE_FRAME frame1,
- MV_REFERENCE_FRAME frame2) {
+// Check if either frame is within the cutoff.
+static INLINE bool in_single_ref_cutoff(int64_t *ref_frame_rd,
+ MV_REFERENCE_FRAME frame1,
+ MV_REFERENCE_FRAME frame2) {
#if CONFIG_NEW_REF_SIGNALING
- assert(is_inter_ref_frame(frame2));
- return ref_frame_rd[frame1] <= ref_frame_rd[INTRA_FRAME_INDEX] ||
- ref_frame_rd[frame2] <= ref_frame_rd[INTRA_FRAME_INDEX];
+ assert(is_inter_ref_frame(frame2));
+ return ref_frame_rd[frame1] <= ref_frame_rd[INTRA_FRAME_INDEX] ||
+ ref_frame_rd[frame2] <= ref_frame_rd[INTRA_FRAME_INDEX];
#else
assert(frame2 > 0);
return ref_frame_rd[frame1] <= ref_frame_rd[0] ||
ref_frame_rd[frame2] <= ref_frame_rd[0];
#endif // CONFIG_NEW_REF_SIGNALING
- }
+}
- static AOM_INLINE void evaluate_motion_mode_for_winner_candidates(
- const AV1_COMP *const cpi, MACROBLOCK *const x, RD_STATS *const rd_cost,
- HandleInterModeArgs *const args, TileDataEnc *const tile_data,
- PICK_MODE_CONTEXT *const ctx,
- struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE],
- const motion_mode_best_st_candidate *const best_motion_mode_cands,
- int do_tx_search, const BLOCK_SIZE bsize, int64_t *const best_est_rd,
- InterModeSearchState *const search_state) {
- const AV1_COMMON *const cm = &cpi->common;
- const int num_planes = av1_num_planes(cm);
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- InterModesInfo *const inter_modes_info = x->inter_modes_info;
- const int num_best_cand = best_motion_mode_cands->num_motion_mode_cand;
+static AOM_INLINE void evaluate_motion_mode_for_winner_candidates(
+ const AV1_COMP *const cpi, MACROBLOCK *const x, RD_STATS *const rd_cost,
+ HandleInterModeArgs *const args, TileDataEnc *const tile_data,
+ PICK_MODE_CONTEXT *const ctx,
+ struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE],
+ const motion_mode_best_st_candidate *const best_motion_mode_cands,
+ int do_tx_search, const BLOCK_SIZE bsize, int64_t *const best_est_rd,
+ InterModeSearchState *const search_state) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const int num_planes = av1_num_planes(cm);
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ InterModesInfo *const inter_modes_info = x->inter_modes_info;
+ const int num_best_cand = best_motion_mode_cands->num_motion_mode_cand;
- for (int cand = 0; cand < num_best_cand; cand++) {
- RD_STATS rd_stats;
- RD_STATS rd_stats_y;
- RD_STATS rd_stats_uv;
- av1_init_rd_stats(&rd_stats);
- av1_init_rd_stats(&rd_stats_y);
- av1_init_rd_stats(&rd_stats_uv);
- int rate_mv;
+ for (int cand = 0; cand < num_best_cand; cand++) {
+ RD_STATS rd_stats;
+ RD_STATS rd_stats_y;
+ RD_STATS rd_stats_uv;
+ av1_init_rd_stats(&rd_stats);
+ av1_init_rd_stats(&rd_stats_y);
+ av1_init_rd_stats(&rd_stats_uv);
+ int rate_mv;
- rate_mv = best_motion_mode_cands->motion_mode_cand[cand].rate_mv;
- args->skip_motion_mode =
- best_motion_mode_cands->motion_mode_cand[cand].skip_motion_mode;
- *mbmi = best_motion_mode_cands->motion_mode_cand[cand].mbmi;
- rd_stats.rate =
- best_motion_mode_cands->motion_mode_cand[cand].rate2_nocoeff;
+ rate_mv = best_motion_mode_cands->motion_mode_cand[cand].rate_mv;
+ args->skip_motion_mode =
+ best_motion_mode_cands->motion_mode_cand[cand].skip_motion_mode;
+ *mbmi = best_motion_mode_cands->motion_mode_cand[cand].mbmi;
+ rd_stats.rate =
+ best_motion_mode_cands->motion_mode_cand[cand].rate2_nocoeff;
- // Continue if the best candidate is compound.
- if (!is_inter_singleref_mode(mbmi->mode)) continue;
+ // Continue if the best candidate is compound.
+ if (!is_inter_singleref_mode(mbmi->mode)) continue;
- x->txfm_search_info.skip_txfm = 0;
- struct macroblockd_plane *p = xd->plane;
- const BUFFER_SET orig_dst = {
- { p[0].dst.buf, p[1].dst.buf, p[2].dst.buf },
- { p[0].dst.stride, p[1].dst.stride, p[2].dst.stride },
- };
+ x->txfm_search_info.skip_txfm = 0;
+ struct macroblockd_plane *p = xd->plane;
+ const BUFFER_SET orig_dst = {
+ { p[0].dst.buf, p[1].dst.buf, p[2].dst.buf },
+ { p[0].dst.stride, p[1].dst.stride, p[2].dst.stride },
+ };
- set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
- // Initialize motion mode to simple translation
- // Calculation of switchable rate depends on it.
- mbmi->motion_mode = 0;
- const int is_comp_pred = is_inter_ref_frame(mbmi->ref_frame[1]);
- for (int i = 0; i < num_planes; i++) {
+ set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+ // Initialize motion mode to simple translation
+ // Calculation of switchable rate depends on it.
+ mbmi->motion_mode = 0;
+ const int is_comp_pred = is_inter_ref_frame(mbmi->ref_frame[1]);
+ for (int i = 0; i < num_planes; i++) {
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- xd->plane[i].pre[0] =
- yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[0])][i];
- if (is_comp_pred)
- xd->plane[i].pre[1] =
- yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[1])][i];
+ xd->plane[i].pre[0] = yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[0])][i];
+ if (is_comp_pred)
+ xd->plane[i].pre[1] =
+ yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[1])][i];
#else
xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
if (is_comp_pred) xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i];
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- }
+ }
- int64_t skip_rd[2] = { search_state->best_skip_rd[0],
- search_state->best_skip_rd[1] };
- int64_t ret_value = motion_mode_rd(
- cpi, tile_data, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv, args,
- search_state->best_rd, skip_rd, &rate_mv, &orig_dst, best_est_rd,
- do_tx_search, inter_modes_info, 1);
+ int64_t skip_rd[2] = { search_state->best_skip_rd[0],
+ search_state->best_skip_rd[1] };
+ int64_t ret_value = motion_mode_rd(
+ cpi, tile_data, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv, args,
+ search_state->best_rd, skip_rd, &rate_mv, &orig_dst, best_est_rd,
+ do_tx_search, inter_modes_info, 1);
- if (ret_value != INT64_MAX) {
- rd_stats.rdcost = RDCOST(x->rdmult, rd_stats.rate, rd_stats.dist);
- MV_REFERENCE_FRAME refs[2] = { mbmi->ref_frame[0], mbmi->ref_frame[1] };
- // Collect mode stats for multiwinner mode processing
- store_winner_mode_stats(
- &cpi->common, x, mbmi, &rd_stats, &rd_stats_y, &rd_stats_uv, refs,
- mbmi->mode, NULL, bsize, rd_stats.rdcost,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, do_tx_search);
- if (rd_stats.rdcost < search_state->best_rd) {
- update_search_state(search_state, rd_cost, ctx, &rd_stats,
- &rd_stats_y, &rd_stats_uv, mbmi->mode, x,
- do_tx_search);
- if (do_tx_search) search_state->best_skip_rd[0] = skip_rd[0];
- }
+ if (ret_value != INT64_MAX) {
+ rd_stats.rdcost = RDCOST(x->rdmult, rd_stats.rate, rd_stats.dist);
+ MV_REFERENCE_FRAME refs[2] = { mbmi->ref_frame[0], mbmi->ref_frame[1] };
+ // Collect mode stats for multiwinner mode processing
+ store_winner_mode_stats(
+ &cpi->common, x, mbmi, &rd_stats, &rd_stats_y, &rd_stats_uv, refs,
+ mbmi->mode, NULL, bsize, rd_stats.rdcost,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type, do_tx_search);
+ if (rd_stats.rdcost < search_state->best_rd) {
+ update_search_state(search_state, rd_cost, ctx, &rd_stats, &rd_stats_y,
+ &rd_stats_uv, mbmi->mode, x, do_tx_search);
+ if (do_tx_search) search_state->best_skip_rd[0] = skip_rd[0];
}
}
}
+}
- /*!\cond */
- // Arguments for speed feature pruning of inter mode search
- typedef struct {
- int *skip_motion_mode;
- mode_skip_mask_t *mode_skip_mask;
- InterModeSearchState *search_state;
- int skip_ref_frame_mask;
- int reach_first_comp_mode;
- int mode_thresh_mul_fact;
- int *num_single_modes_processed;
- int prune_cpd_using_sr_stats_ready;
- } InterModeSFArgs;
- /*!\endcond */
+/*!\cond */
+// Arguments for speed feature pruning of inter mode search
+typedef struct {
+ int *skip_motion_mode;
+ mode_skip_mask_t *mode_skip_mask;
+ InterModeSearchState *search_state;
+ int skip_ref_frame_mask;
+ int reach_first_comp_mode;
+ int mode_thresh_mul_fact;
+ int *num_single_modes_processed;
+ int prune_cpd_using_sr_stats_ready;
+} InterModeSFArgs;
+/*!\endcond */
- static int skip_inter_mode(AV1_COMP * cpi, MACROBLOCK * x,
- const BLOCK_SIZE bsize, int64_t *ref_frame_rd,
+static int skip_inter_mode(AV1_COMP *cpi, MACROBLOCK *x, const BLOCK_SIZE bsize,
+ int64_t *ref_frame_rd,
#if CONFIG_NEW_REF_SIGNALING
- PREDICTION_MODE this_mode,
- const MV_REFERENCE_FRAME *ref_frames,
+ PREDICTION_MODE this_mode,
+ const MV_REFERENCE_FRAME *ref_frames,
#else
int midx,
#endif // CONFIG_NEW_REF_SIGNALING
- InterModeSFArgs *args) {
- const SPEED_FEATURES *const sf = &cpi->sf;
- MACROBLOCKD *const xd = &x->e_mbd;
+ InterModeSFArgs *args) {
+ const SPEED_FEATURES *const sf = &cpi->sf;
+ MACROBLOCKD *const xd = &x->e_mbd;
#if !CONFIG_NEW_REF_SIGNALING
- // Get the actual prediction mode we are trying in this iteration
- const THR_MODES mode_enum = av1_default_mode_order[midx];
- const MODE_DEFINITION *mode_def = &av1_mode_defs[mode_enum];
- const PREDICTION_MODE this_mode = mode_def->mode;
- const MV_REFERENCE_FRAME *ref_frames = mode_def->ref_frame;
+ // Get the actual prediction mode we are trying in this iteration
+ const THR_MODES mode_enum = av1_default_mode_order[midx];
+ const MODE_DEFINITION *mode_def = &av1_mode_defs[mode_enum];
+ const PREDICTION_MODE this_mode = mode_def->mode;
+ const MV_REFERENCE_FRAME *ref_frames = mode_def->ref_frame;
#endif // CONFIG_NEW_REF_SIGNALING
- const MV_REFERENCE_FRAME ref_frame = ref_frames[0];
- const MV_REFERENCE_FRAME second_ref_frame = ref_frames[1];
- const int comp_pred = is_inter_ref_frame(second_ref_frame);
+ const MV_REFERENCE_FRAME ref_frame = ref_frames[0];
+ const MV_REFERENCE_FRAME second_ref_frame = ref_frames[1];
+ const int comp_pred = is_inter_ref_frame(second_ref_frame);
#if CONFIG_TIP
- if (is_tip_ref_frame(ref_frame) &&
- cpi->common.features.tip_frame_mode == TIP_FRAME_DISABLED) {
- return 1;
- } else if (is_tip_ref_frame(ref_frame)) {
- return 0;
- }
+ if (is_tip_ref_frame(ref_frame) &&
+ cpi->common.features.tip_frame_mode == TIP_FRAME_DISABLED) {
+ return 1;
+ } else if (is_tip_ref_frame(ref_frame)) {
+ return 0;
+ }
#endif // CONFIG_TIP
- // Check if this mode should be skipped because it is incompatible with the
- // current frame
- if (inter_mode_compatible_skip(cpi, x, bsize, this_mode, ref_frames))
- return 1;
- const int ret = inter_mode_search_order_independent_skip(
- cpi, x, args->mode_skip_mask, args->search_state,
- args->skip_ref_frame_mask, this_mode, ref_frames);
- if (ret == 1) return 1;
- *(args->skip_motion_mode) = (ret == 2);
+ // Check if this mode should be skipped because it is incompatible with the
+ // current frame
+ if (inter_mode_compatible_skip(cpi, x, bsize, this_mode, ref_frames))
+ return 1;
+ const int ret = inter_mode_search_order_independent_skip(
+ cpi, x, args->mode_skip_mask, args->search_state,
+ args->skip_ref_frame_mask, this_mode, ref_frames);
+ if (ret == 1) return 1;
+ *(args->skip_motion_mode) = (ret == 2);
- // We've reached the first compound prediction mode, get stats from the
- // single reference predictors to help with pruning
- if (sf->inter_sf.prune_comp_search_by_single_result > 0 && comp_pred &&
- args->reach_first_comp_mode == 0) {
- analyze_single_states(cpi, args->search_state);
- args->reach_first_comp_mode = 1;
- }
+ // We've reached the first compound prediction mode, get stats from the
+ // single reference predictors to help with pruning
+ if (sf->inter_sf.prune_comp_search_by_single_result > 0 && comp_pred &&
+ args->reach_first_comp_mode == 0) {
+ analyze_single_states(cpi, args->search_state);
+ args->reach_first_comp_mode = 1;
+ }
- // Prune aggressively when best mode is skippable.
- int mul_fact = args->search_state->best_mode_skippable
- ? args->mode_thresh_mul_fact
- : (1 << MODE_THRESH_QBITS);
+ // Prune aggressively when best mode is skippable.
+ int mul_fact = args->search_state->best_mode_skippable
+ ? args->mode_thresh_mul_fact
+ : (1 << MODE_THRESH_QBITS);
#if CONFIG_NEW_REF_SIGNALING
- int64_t mode_threshold =
- (args->search_state->mode_threshold[this_mode] * mul_fact) >>
- MODE_THRESH_QBITS;
+ int64_t mode_threshold =
+ (args->search_state->mode_threshold[this_mode] * mul_fact) >>
+ MODE_THRESH_QBITS;
#else
int64_t mode_threshold =
(args->search_state->mode_threshold[mode_enum] * mul_fact) >>
MODE_THRESH_QBITS;
#endif // CONFIG_NEW_REF_SIGNALING
- if (args->search_state->best_rd < mode_threshold) return 1;
+ if (args->search_state->best_rd < mode_threshold) return 1;
- // Skip this compound mode based on the RD results from the single
- // prediction modes
- if (sf->inter_sf.prune_comp_search_by_single_result > 0 &&
+ // Skip this compound mode based on the RD results from the single
+ // prediction modes
+ if (sf->inter_sf.prune_comp_search_by_single_result > 0 &&
#if CONFIG_OPTFLOW_REFINEMENT
- this_mode < NEAR_NEARMV_OPTFLOW &&
+ this_mode < NEAR_NEARMV_OPTFLOW &&
#endif // CONFIG_OPTFLOW_REFINEMENT
- comp_pred) {
- if (compound_skip_by_single_states(cpi, args->search_state, this_mode,
- ref_frame, second_ref_frame, x))
- return 1;
- }
-
- // Speed features to prune out INTRA frames
- if (ref_frame == INTRA_FRAME) {
- // Intra modes will be handled in another loop later
+ comp_pred) {
+ if (compound_skip_by_single_states(cpi, args->search_state, this_mode,
+ ref_frame, second_ref_frame, x))
return 1;
- }
+ }
- if (sf->inter_sf.prune_compound_using_single_ref && comp_pred) {
- // After we done with single reference modes, find the 2nd best RD
- // for a reference frame. Only search compound modes that have a reference
- // frame at least as good as 110% the best one.
- if (!args->prune_cpd_using_sr_stats_ready &&
+ // Speed features to prune out INTRA frames
+ if (ref_frame == INTRA_FRAME) {
+ // Intra modes will be handled in another loop later
+ return 1;
+ }
+
+ if (sf->inter_sf.prune_compound_using_single_ref && comp_pred) {
+ // After we done with single reference modes, find the 2nd best RD
+ // for a reference frame. Only search compound modes that have a reference
+ // frame at least as good as 110% the best one.
+ if (!args->prune_cpd_using_sr_stats_ready &&
#if CONFIG_NEW_REF_SIGNALING
- *args->num_single_modes_processed ==
- cpi->common.ref_frames_info.num_total_refs *
- SINGLE_INTER_MODE_NUM) {
+ *args->num_single_modes_processed ==
+ cpi->common.ref_frames_info.num_total_refs *
+ SINGLE_INTER_MODE_NUM) {
#else
*args->num_single_modes_processed == NUM_SINGLE_REF_MODES) {
#endif // CONFIG_NEW_REF_SIGNALING
- find_top_ref(ref_frame_rd);
- args->prune_cpd_using_sr_stats_ready = 1;
- }
- if (args->prune_cpd_using_sr_stats_ready &&
- !in_single_ref_cutoff(ref_frame_rd, ref_frame, second_ref_frame))
- return 1;
+ find_top_ref(ref_frame_rd);
+ args->prune_cpd_using_sr_stats_ready = 1;
}
-
- if (sf->inter_sf.prune_compound_using_neighbors && comp_pred) {
- if (compound_skip_using_neighbor_refs(
- xd, this_mode, ref_frames,
- sf->inter_sf.prune_compound_using_neighbors))
- return 1;
- }
-
- if (sf->inter_sf.prune_comp_using_best_single_mode_ref && comp_pred) {
- if (skip_compound_using_best_single_mode_ref(
- this_mode, ref_frames, args->search_state->best_single_mode,
- sf->inter_sf.prune_comp_using_best_single_mode_ref))
- return 1;
- }
-
- return 0;
+ if (args->prune_cpd_using_sr_stats_ready &&
+ !in_single_ref_cutoff(ref_frame_rd, ref_frame, second_ref_frame))
+ return 1;
}
- static void record_best_compound(
- REFERENCE_MODE reference_mode, RD_STATS * rd_stats, int comp_pred,
- int rdmult, InterModeSearchState *search_state, int compmode_cost) {
- int64_t single_rd, hybrid_rd, single_rate, hybrid_rate;
-
- if (reference_mode == REFERENCE_MODE_SELECT) {
- single_rate = rd_stats->rate - compmode_cost;
- hybrid_rate = rd_stats->rate;
- } else {
- single_rate = rd_stats->rate;
- hybrid_rate = rd_stats->rate + compmode_cost;
- }
-
- single_rd = RDCOST(rdmult, single_rate, rd_stats->dist);
- hybrid_rd = RDCOST(rdmult, hybrid_rate, rd_stats->dist);
-
- if (!comp_pred) {
- if (single_rd <
- search_state->intra_search_state.best_pred_rd[SINGLE_REFERENCE])
- search_state->intra_search_state.best_pred_rd[SINGLE_REFERENCE] =
- single_rd;
- } else {
- if (single_rd <
- search_state->intra_search_state.best_pred_rd[COMPOUND_REFERENCE])
- search_state->intra_search_state.best_pred_rd[COMPOUND_REFERENCE] =
- single_rd;
- }
- if (hybrid_rd <
- search_state->intra_search_state.best_pred_rd[REFERENCE_MODE_SELECT])
- search_state->intra_search_state.best_pred_rd[REFERENCE_MODE_SELECT] =
- hybrid_rd;
+ if (sf->inter_sf.prune_compound_using_neighbors && comp_pred) {
+ if (compound_skip_using_neighbor_refs(
+ xd, this_mode, ref_frames,
+ sf->inter_sf.prune_compound_using_neighbors))
+ return 1;
}
- // Does a transform search over a list of the best inter mode candidates.
- // This is called if the original mode search computed an RD estimate
- // for the transform search rather than doing a full search.
- static void tx_search_best_inter_candidates(
- AV1_COMP * cpi, TileDataEnc * tile_data, MACROBLOCK * x,
- int64_t best_rd_so_far, BLOCK_SIZE bsize,
- struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE], int mi_row,
- int mi_col, InterModeSearchState *search_state, RD_STATS *rd_cost,
- PICK_MODE_CONTEXT *ctx) {
- AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- TxfmSearchInfo *txfm_info = &x->txfm_search_info;
- const ModeCosts *mode_costs = &x->mode_costs;
- const int num_planes = av1_num_planes(cm);
- const int skip_ctx = av1_get_skip_txfm_context(xd);
- MB_MODE_INFO *const mbmi = xd->mi[0];
- InterModesInfo *inter_modes_info = x->inter_modes_info;
- inter_modes_info_sort(inter_modes_info, inter_modes_info->rd_idx_pair_arr);
- search_state->best_rd = best_rd_so_far;
- search_state->best_mbmode.mode = MODE_INVALID;
- // Initialize best mode stats for winner mode processing
- x->winner_mode_count = 0;
- const MV_REFERENCE_FRAME init_refs[2] = { -1, -1 };
- store_winner_mode_stats(&cpi->common, x, mbmi, NULL, NULL, NULL, init_refs,
- MODE_INVALID, NULL, bsize, best_rd_so_far,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, 0);
- const int64_t top_est_rd =
- inter_modes_info->num > 0
- ? inter_modes_info
- ->est_rd_arr[inter_modes_info->rd_idx_pair_arr[0].idx]
- : INT64_MAX;
- // Iterate over best inter mode candidates and perform tx search
- for (int j = 0; j < inter_modes_info->num; ++j) {
- const int data_idx = inter_modes_info->rd_idx_pair_arr[j].idx;
- *mbmi = inter_modes_info->mbmi_arr[data_idx];
- int64_t curr_est_rd = inter_modes_info->est_rd_arr[data_idx];
- if (curr_est_rd * 0.80 > top_est_rd) break;
+ if (sf->inter_sf.prune_comp_using_best_single_mode_ref && comp_pred) {
+ if (skip_compound_using_best_single_mode_ref(
+ this_mode, ref_frames, args->search_state->best_single_mode,
+ sf->inter_sf.prune_comp_using_best_single_mode_ref))
+ return 1;
+ }
- txfm_info->skip_txfm = 0;
- set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+ return 0;
+}
- // Select prediction reference frames.
- const int is_comp_pred = is_inter_ref_frame(mbmi->ref_frame[1]);
- for (int i = 0; i < num_planes; i++) {
+static void record_best_compound(REFERENCE_MODE reference_mode,
+ RD_STATS *rd_stats, int comp_pred, int rdmult,
+ InterModeSearchState *search_state,
+ int compmode_cost) {
+ int64_t single_rd, hybrid_rd, single_rate, hybrid_rate;
+
+ if (reference_mode == REFERENCE_MODE_SELECT) {
+ single_rate = rd_stats->rate - compmode_cost;
+ hybrid_rate = rd_stats->rate;
+ } else {
+ single_rate = rd_stats->rate;
+ hybrid_rate = rd_stats->rate + compmode_cost;
+ }
+
+ single_rd = RDCOST(rdmult, single_rate, rd_stats->dist);
+ hybrid_rd = RDCOST(rdmult, hybrid_rate, rd_stats->dist);
+
+ if (!comp_pred) {
+ if (single_rd <
+ search_state->intra_search_state.best_pred_rd[SINGLE_REFERENCE])
+ search_state->intra_search_state.best_pred_rd[SINGLE_REFERENCE] =
+ single_rd;
+ } else {
+ if (single_rd <
+ search_state->intra_search_state.best_pred_rd[COMPOUND_REFERENCE])
+ search_state->intra_search_state.best_pred_rd[COMPOUND_REFERENCE] =
+ single_rd;
+ }
+ if (hybrid_rd <
+ search_state->intra_search_state.best_pred_rd[REFERENCE_MODE_SELECT])
+ search_state->intra_search_state.best_pred_rd[REFERENCE_MODE_SELECT] =
+ hybrid_rd;
+}
+
+// Does a transform search over a list of the best inter mode candidates.
+// This is called if the original mode search computed an RD estimate
+// for the transform search rather than doing a full search.
+static void tx_search_best_inter_candidates(
+ AV1_COMP *cpi, TileDataEnc *tile_data, MACROBLOCK *x,
+ int64_t best_rd_so_far, BLOCK_SIZE bsize,
+ struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE], int mi_row,
+ int mi_col, InterModeSearchState *search_state, RD_STATS *rd_cost,
+ PICK_MODE_CONTEXT *ctx) {
+ AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ TxfmSearchInfo *txfm_info = &x->txfm_search_info;
+ const ModeCosts *mode_costs = &x->mode_costs;
+ const int num_planes = av1_num_planes(cm);
+ const int skip_ctx = av1_get_skip_txfm_context(xd);
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ InterModesInfo *inter_modes_info = x->inter_modes_info;
+ inter_modes_info_sort(inter_modes_info, inter_modes_info->rd_idx_pair_arr);
+ search_state->best_rd = best_rd_so_far;
+ search_state->best_mbmode.mode = MODE_INVALID;
+ // Initialize best mode stats for winner mode processing
+ x->winner_mode_count = 0;
+ const MV_REFERENCE_FRAME init_refs[2] = { -1, -1 };
+ store_winner_mode_stats(&cpi->common, x, mbmi, NULL, NULL, NULL, init_refs,
+ MODE_INVALID, NULL, bsize, best_rd_so_far,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type, 0);
+ const int64_t top_est_rd =
+ inter_modes_info->num > 0
+ ? inter_modes_info
+ ->est_rd_arr[inter_modes_info->rd_idx_pair_arr[0].idx]
+ : INT64_MAX;
+ // Iterate over best inter mode candidates and perform tx search
+ for (int j = 0; j < inter_modes_info->num; ++j) {
+ const int data_idx = inter_modes_info->rd_idx_pair_arr[j].idx;
+ *mbmi = inter_modes_info->mbmi_arr[data_idx];
+ int64_t curr_est_rd = inter_modes_info->est_rd_arr[data_idx];
+ if (curr_est_rd * 0.80 > top_est_rd) break;
+
+ txfm_info->skip_txfm = 0;
+ set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+
+ // Select prediction reference frames.
+ const int is_comp_pred = is_inter_ref_frame(mbmi->ref_frame[1]);
+ for (int i = 0; i < num_planes; i++) {
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- xd->plane[i].pre[0] =
- yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[0])][i];
- if (is_comp_pred)
- xd->plane[i].pre[1] =
- yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[1])][i];
+ xd->plane[i].pre[0] = yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[0])][i];
+ if (is_comp_pred)
+ xd->plane[i].pre[1] =
+ yv12_mb[COMPACT_INDEX0_NRS(mbmi->ref_frame[1])][i];
#else
xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
if (is_comp_pred) xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i];
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- }
+ }
- // Build the prediction for this mode
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
- av1_num_planes(cm) - 1);
- if (mbmi->motion_mode == OBMC_CAUSAL) {
- av1_build_obmc_inter_predictors_sb(cm, xd);
- }
+ // Build the prediction for this mode
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
+ av1_num_planes(cm) - 1);
+ if (mbmi->motion_mode == OBMC_CAUSAL) {
+ av1_build_obmc_inter_predictors_sb(cm, xd);
+ }
- // Initialize RD stats
- RD_STATS rd_stats;
- RD_STATS rd_stats_y;
- RD_STATS rd_stats_uv;
- const int mode_rate = inter_modes_info->mode_rate_arr[data_idx];
- int64_t skip_rd = INT64_MAX;
- if (cpi->sf.inter_sf.txfm_rd_gate_level) {
- // Check if the mode is good enough based on skip RD
- int64_t curr_sse = inter_modes_info->sse_arr[data_idx];
- skip_rd = RDCOST(x->rdmult, mode_rate, curr_sse);
- int eval_txfm =
- check_txfm_eval(x, bsize, search_state->best_skip_rd[0], skip_rd,
- cpi->sf.inter_sf.txfm_rd_gate_level, 0);
- if (!eval_txfm) continue;
- }
+ // Initialize RD stats
+ RD_STATS rd_stats;
+ RD_STATS rd_stats_y;
+ RD_STATS rd_stats_uv;
+ const int mode_rate = inter_modes_info->mode_rate_arr[data_idx];
+ int64_t skip_rd = INT64_MAX;
+ if (cpi->sf.inter_sf.txfm_rd_gate_level) {
+ // Check if the mode is good enough based on skip RD
+ int64_t curr_sse = inter_modes_info->sse_arr[data_idx];
+ skip_rd = RDCOST(x->rdmult, mode_rate, curr_sse);
+ int eval_txfm =
+ check_txfm_eval(x, bsize, search_state->best_skip_rd[0], skip_rd,
+ cpi->sf.inter_sf.txfm_rd_gate_level, 0);
+ if (!eval_txfm) continue;
+ }
- // Do the transform search
- if (!av1_txfm_search(cpi, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv,
- mode_rate, search_state->best_rd)) {
- continue;
- } else if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1) {
- inter_mode_data_push(
- tile_data, mbmi->sb_type[PLANE_TYPE_Y], rd_stats.sse, rd_stats.dist,
- rd_stats_y.rate + rd_stats_uv.rate +
- mode_costs->skip_txfm_cost
- [skip_ctx][mbmi->skip_txfm[xd->tree_type == CHROMA_PART]]);
- }
- rd_stats.rdcost = RDCOST(x->rdmult, rd_stats.rate, rd_stats.dist);
+ // Do the transform search
+ if (!av1_txfm_search(cpi, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv,
+ mode_rate, search_state->best_rd)) {
+ continue;
+ } else if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1) {
+ inter_mode_data_push(
+ tile_data, mbmi->sb_type[PLANE_TYPE_Y], rd_stats.sse, rd_stats.dist,
+ rd_stats_y.rate + rd_stats_uv.rate +
+ mode_costs->skip_txfm_cost
+ [skip_ctx][mbmi->skip_txfm[xd->tree_type == CHROMA_PART]]);
+ }
+ rd_stats.rdcost = RDCOST(x->rdmult, rd_stats.rate, rd_stats.dist);
- const MV_REFERENCE_FRAME refs[2] = { mbmi->ref_frame[0],
- mbmi->ref_frame[1] };
+ const MV_REFERENCE_FRAME refs[2] = { mbmi->ref_frame[0],
+ mbmi->ref_frame[1] };
- // Collect mode stats for multiwinner mode processing
- const int txfm_search_done = 1;
- store_winner_mode_stats(
- &cpi->common, x, mbmi, &rd_stats, &rd_stats_y, &rd_stats_uv, refs,
- mbmi->mode, NULL, bsize, rd_stats.rdcost,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, txfm_search_done);
+ // Collect mode stats for multiwinner mode processing
+ const int txfm_search_done = 1;
+ store_winner_mode_stats(
+ &cpi->common, x, mbmi, &rd_stats, &rd_stats_y, &rd_stats_uv, refs,
+ mbmi->mode, NULL, bsize, rd_stats.rdcost,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type, txfm_search_done);
- if (rd_stats.rdcost < search_state->best_rd) {
- update_search_state(search_state, rd_cost, ctx, &rd_stats, &rd_stats_y,
- &rd_stats_uv, mbmi->mode, x, txfm_search_done);
- search_state->best_skip_rd[0] = skip_rd;
- }
+ if (rd_stats.rdcost < search_state->best_rd) {
+ update_search_state(search_state, rd_cost, ctx, &rd_stats, &rd_stats_y,
+ &rd_stats_uv, mbmi->mode, x, txfm_search_done);
+ search_state->best_skip_rd[0] = skip_rd;
+ }
+ }
+}
+
+// Indicates number of winner simple translation modes to be used
+static const unsigned int num_winner_motion_modes[3] = { 0, 10, 3 };
+
+// Adds a motion mode to the candidate list for motion_mode_for_winner_cand
+// speed feature. This list consists of modes that have only searched
+// SIMPLE_TRANSLATION. The final list will be used to search other motion
+// modes after the initial RD search.
+static void handle_winner_cand(
+ MB_MODE_INFO *const mbmi,
+ motion_mode_best_st_candidate *best_motion_mode_cands,
+ int max_winner_motion_mode_cand, int64_t this_rd,
+ motion_mode_candidate *motion_mode_cand, int skip_motion_mode) {
+ // Number of current motion mode candidates in list
+ const int num_motion_mode_cand = best_motion_mode_cands->num_motion_mode_cand;
+ int valid_motion_mode_cand_loc = num_motion_mode_cand;
+
+ // find the best location to insert new motion mode candidate
+ for (int j = 0; j < num_motion_mode_cand; j++) {
+ if (this_rd < best_motion_mode_cands->motion_mode_cand[j].rd_cost) {
+ valid_motion_mode_cand_loc = j;
+ break;
}
}
- // Indicates number of winner simple translation modes to be used
- static const unsigned int num_winner_motion_modes[3] = { 0, 10, 3 };
-
- // Adds a motion mode to the candidate list for motion_mode_for_winner_cand
- // speed feature. This list consists of modes that have only searched
- // SIMPLE_TRANSLATION. The final list will be used to search other motion
- // modes after the initial RD search.
- static void handle_winner_cand(
- MB_MODE_INFO *const mbmi,
- motion_mode_best_st_candidate *best_motion_mode_cands,
- int max_winner_motion_mode_cand, int64_t this_rd,
- motion_mode_candidate *motion_mode_cand, int skip_motion_mode) {
- // Number of current motion mode candidates in list
- const int num_motion_mode_cand =
- best_motion_mode_cands->num_motion_mode_cand;
- int valid_motion_mode_cand_loc = num_motion_mode_cand;
-
- // find the best location to insert new motion mode candidate
- for (int j = 0; j < num_motion_mode_cand; j++) {
- if (this_rd < best_motion_mode_cands->motion_mode_cand[j].rd_cost) {
- valid_motion_mode_cand_loc = j;
- break;
- }
- }
-
- // Insert motion mode if location is found
- if (valid_motion_mode_cand_loc < max_winner_motion_mode_cand) {
- if (num_motion_mode_cand > 0 &&
- valid_motion_mode_cand_loc < max_winner_motion_mode_cand - 1)
- memmove(&best_motion_mode_cands
- ->motion_mode_cand[valid_motion_mode_cand_loc + 1],
- &best_motion_mode_cands
- ->motion_mode_cand[valid_motion_mode_cand_loc],
- (AOMMIN(num_motion_mode_cand, max_winner_motion_mode_cand - 1) -
- valid_motion_mode_cand_loc) *
- sizeof(best_motion_mode_cands->motion_mode_cand[0]));
- motion_mode_cand->mbmi = *mbmi;
- motion_mode_cand->rd_cost = this_rd;
- motion_mode_cand->skip_motion_mode = skip_motion_mode;
- best_motion_mode_cands->motion_mode_cand[valid_motion_mode_cand_loc] =
- *motion_mode_cand;
- best_motion_mode_cands->num_motion_mode_cand =
- AOMMIN(max_winner_motion_mode_cand,
- best_motion_mode_cands->num_motion_mode_cand + 1);
- }
+ // Insert motion mode if location is found
+ if (valid_motion_mode_cand_loc < max_winner_motion_mode_cand) {
+ if (num_motion_mode_cand > 0 &&
+ valid_motion_mode_cand_loc < max_winner_motion_mode_cand - 1)
+ memmove(
+ &best_motion_mode_cands
+ ->motion_mode_cand[valid_motion_mode_cand_loc + 1],
+ &best_motion_mode_cands->motion_mode_cand[valid_motion_mode_cand_loc],
+ (AOMMIN(num_motion_mode_cand, max_winner_motion_mode_cand - 1) -
+ valid_motion_mode_cand_loc) *
+ sizeof(best_motion_mode_cands->motion_mode_cand[0]));
+ motion_mode_cand->mbmi = *mbmi;
+ motion_mode_cand->rd_cost = this_rd;
+ motion_mode_cand->skip_motion_mode = skip_motion_mode;
+ best_motion_mode_cands->motion_mode_cand[valid_motion_mode_cand_loc] =
+ *motion_mode_cand;
+ best_motion_mode_cands->num_motion_mode_cand =
+ AOMMIN(max_winner_motion_mode_cand,
+ best_motion_mode_cands->num_motion_mode_cand + 1);
}
+}
#if CONFIG_TIP
#if CONFIG_NEW_REF_SIGNALING
- static INLINE int is_tip_mode(PREDICTION_MODE mode) {
+static INLINE int is_tip_mode(PREDICTION_MODE mode) {
#if IMPROVED_AMVD
- return (mode == NEARMV || mode == NEWMV || mode == AMVDNEWMV);
+ return (mode == NEARMV || mode == NEWMV || mode == AMVDNEWMV);
#else
- return (mode == NEARMV || mode == NEWMV);
+ return (mode == NEARMV || mode == NEWMV);
#endif // IMPROVED_AMVD
- }
+}
#else
static INLINE int is_tip_mode(THR_MODES mode) {
#if IMPROVED_AMVD
@@ -7567,160 +7156,163 @@
#endif // CONFIG_NEW_REF_SIGNALING
#endif // CONFIG_TIP
- // TODO(chiyotsai@google.com): See the todo for av1_rd_pick_intra_mode_sb.
- void av1_rd_pick_inter_mode_sb(
- struct AV1_COMP * cpi, struct TileDataEnc * tile_data,
- struct macroblock * x, struct RD_STATS * rd_cost, BLOCK_SIZE bsize,
- PICK_MODE_CONTEXT * ctx, int64_t best_rd_so_far) {
- AV1_COMMON *const cm = &cpi->common;
- const FeatureFlags *const features = &cm->features;
- const int num_planes = av1_num_planes(cm);
- const SPEED_FEATURES *const sf = &cpi->sf;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- TxfmSearchInfo *txfm_info = &x->txfm_search_info;
- int i;
- const ModeCosts *mode_costs = &x->mode_costs;
- const int *comp_inter_cost =
- mode_costs->comp_inter_cost[av1_get_reference_mode_context(cm, xd)];
+// TODO(chiyotsai@google.com): See the todo for av1_rd_pick_intra_mode_sb.
+void av1_rd_pick_inter_mode_sb(struct AV1_COMP *cpi,
+ struct TileDataEnc *tile_data,
+ struct macroblock *x, struct RD_STATS *rd_cost,
+ BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
+ int64_t best_rd_so_far) {
+ AV1_COMMON *const cm = &cpi->common;
+ const FeatureFlags *const features = &cm->features;
+ const int num_planes = av1_num_planes(cm);
+ const SPEED_FEATURES *const sf = &cpi->sf;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ TxfmSearchInfo *txfm_info = &x->txfm_search_info;
+ int i;
+ const ModeCosts *mode_costs = &x->mode_costs;
+ const int *comp_inter_cost =
+ mode_costs->comp_inter_cost[av1_get_reference_mode_context(cm, xd)];
#if CONFIG_IBC_SR_EXT
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
#endif // CONFIG_IBC_SR_EXT
- InterModeSearchState search_state;
- init_inter_mode_search_state(&search_state, cpi, x, bsize, best_rd_so_far);
- INTERINTRA_MODE interintra_modes[REF_FRAMES] = {
- INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES,
- INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES
- };
+ InterModeSearchState search_state;
+ init_inter_mode_search_state(&search_state, cpi, x, bsize, best_rd_so_far);
+ INTERINTRA_MODE interintra_modes[REF_FRAMES] = {
+ INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES,
+ INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES
+ };
- HandleInterModeArgs args = { { NULL },
- { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE },
- { NULL },
- { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
- MAX_SB_SIZE >> 1 },
- NULL,
- NULL,
- NULL,
- search_state.modelled_rd,
- INT_MAX,
- INT_MAX,
- search_state.simple_rd,
- 0,
- interintra_modes,
- { { 0, { { 0 } }, { 0 }, 0, 0, 0 } },
- 0 };
+ HandleInterModeArgs args = { { NULL },
+ { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE },
+ { NULL },
+ { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
+ MAX_SB_SIZE >> 1 },
+ NULL,
+ NULL,
+ NULL,
+ search_state.modelled_rd,
+ INT_MAX,
+ INT_MAX,
+ search_state.simple_rd,
+ 0,
+ interintra_modes,
+ { { 0, { { 0 } }, { 0 }, 0, 0, 0 } },
+ 0 };
- // Indicates the appropriate number of simple translation winner modes for
- // exhaustive motion mode evaluation
- const int max_winner_motion_mode_cand =
- num_winner_motion_modes[cpi->sf.winner_mode_sf
- .motion_mode_for_winner_cand];
- assert(max_winner_motion_mode_cand <= MAX_WINNER_MOTION_MODES);
- motion_mode_candidate motion_mode_cand;
- motion_mode_best_st_candidate best_motion_mode_cands;
- // Initializing the number of motion mode candidates to zero.
- best_motion_mode_cands.num_motion_mode_cand = 0;
- for (i = 0; i < MAX_WINNER_MOTION_MODES; ++i)
- best_motion_mode_cands.motion_mode_cand[i].rd_cost = INT64_MAX;
+ // Indicates the appropriate number of simple translation winner modes for
+ // exhaustive motion mode evaluation
+ const int max_winner_motion_mode_cand =
+ num_winner_motion_modes[cpi->sf.winner_mode_sf
+ .motion_mode_for_winner_cand];
+ assert(max_winner_motion_mode_cand <= MAX_WINNER_MOTION_MODES);
+ motion_mode_candidate motion_mode_cand;
+ motion_mode_best_st_candidate best_motion_mode_cands;
+ // Initializing the number of motion mode candidates to zero.
+ best_motion_mode_cands.num_motion_mode_cand = 0;
+ for (i = 0; i < MAX_WINNER_MOTION_MODES; ++i)
+ best_motion_mode_cands.motion_mode_cand[i].rd_cost = INT64_MAX;
- for (i = 0; i < SINGLE_REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
+ for (i = 0; i < SINGLE_REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
- av1_invalid_rd_stats(rd_cost);
+ av1_invalid_rd_stats(rd_cost);
- // Ref frames that are selected by square partition blocks.
- int picked_ref_frames_mask = 0;
- if (cpi->sf.inter_sf.prune_ref_frame_for_rect_partitions &&
- mbmi->partition != PARTITION_NONE &&
- mbmi->partition != PARTITION_SPLIT) {
- // prune_ref_frame_for_rect_partitions = 1 implies prune only extended
- // partition blocks. prune_ref_frame_for_rect_partitions >=2
- // implies prune for vert, horiz and extended partition blocks.
- if ((mbmi->partition != PARTITION_VERT &&
- mbmi->partition != PARTITION_HORZ) ||
- cpi->sf.inter_sf.prune_ref_frame_for_rect_partitions >= 2) {
- picked_ref_frames_mask =
- fetch_picked_ref_frames_mask(x, bsize, cm->seq_params.mib_size);
- }
+ // Ref frames that are selected by square partition blocks.
+ int picked_ref_frames_mask = 0;
+ if (cpi->sf.inter_sf.prune_ref_frame_for_rect_partitions &&
+ mbmi->partition != PARTITION_NONE && mbmi->partition != PARTITION_SPLIT) {
+ // prune_ref_frame_for_rect_partitions = 1 implies prune only extended
+ // partition blocks. prune_ref_frame_for_rect_partitions >=2
+ // implies prune for vert, horiz and extended partition blocks.
+ if ((mbmi->partition != PARTITION_VERT &&
+ mbmi->partition != PARTITION_HORZ) ||
+ cpi->sf.inter_sf.prune_ref_frame_for_rect_partitions >= 2) {
+ picked_ref_frames_mask =
+ fetch_picked_ref_frames_mask(x, bsize, cm->seq_params.mib_size);
}
+ }
- // Skip ref frames that never selected by square blocks.
- const int skip_ref_frame_mask =
- picked_ref_frames_mask ? ~picked_ref_frames_mask : 0;
- mode_skip_mask_t mode_skip_mask;
- unsigned int ref_costs_single[SINGLE_REF_FRAMES];
- struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE];
- unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES];
+ // Skip ref frames that never selected by square blocks.
+ const int skip_ref_frame_mask =
+ picked_ref_frames_mask ? ~picked_ref_frames_mask : 0;
+ mode_skip_mask_t mode_skip_mask;
+ unsigned int ref_costs_single[SINGLE_REF_FRAMES];
+ struct buf_2d yv12_mb[SINGLE_REF_FRAMES][MAX_MB_PLANE];
+ unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES];
#if CONFIG_FLEX_MVRES
- set_default_max_mv_precision(mbmi, xd->sbi->sb_mv_precision);
- set_mv_precision(mbmi, mbmi->max_mv_precision);
- set_most_probable_mv_precision(cm, mbmi, bsize);
+ set_default_max_mv_precision(mbmi, xd->sbi->sb_mv_precision);
+#if ADAPTIVE_PRECISION_SETS
+ set_default_precision_set(cm, mbmi, bsize);
+#endif
+ set_mv_precision(mbmi, mbmi->max_mv_precision);
+ set_most_probable_mv_precision(cm, mbmi, bsize);
#endif
- // init params, set frame modes, speed features
- set_params_rd_pick_inter_mode(cpi, x, &args, bsize, &mode_skip_mask,
- skip_ref_frame_mask, ref_costs_single,
- ref_costs_comp, yv12_mb);
+ // init params, set frame modes, speed features
+ set_params_rd_pick_inter_mode(cpi, x, &args, bsize, &mode_skip_mask,
+ skip_ref_frame_mask, ref_costs_single,
+ ref_costs_comp, yv12_mb);
- int64_t best_est_rd = INT64_MAX;
- const InterModeRdModel *md = &tile_data->inter_mode_rd_models[bsize];
- // If do_tx_search is 0, only estimated RD should be computed.
- // If do_tx_search is 1, all modes have TX search performed.
- const int do_tx_search =
- !((cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1 && md->ready) ||
- (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 2 &&
- num_pels_log2_lookup[bsize] > 8));
- InterModesInfo *inter_modes_info = x->inter_modes_info;
- inter_modes_info->num = 0;
+ int64_t best_est_rd = INT64_MAX;
+ const InterModeRdModel *md = &tile_data->inter_mode_rd_models[bsize];
+ // If do_tx_search is 0, only estimated RD should be computed.
+ // If do_tx_search is 1, all modes have TX search performed.
+ const int do_tx_search =
+ !((cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1 && md->ready) ||
+ (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 2 &&
+ num_pels_log2_lookup[bsize] > 8));
+ InterModesInfo *inter_modes_info = x->inter_modes_info;
+ inter_modes_info->num = 0;
- int num_single_modes_processed = 0;
+ int num_single_modes_processed = 0;
- // Temporary buffers used by handle_inter_mode().
- uint8_t *const tmp_buf = get_buf_by_bd(xd, x->tmp_pred_bufs[0]);
+ // Temporary buffers used by handle_inter_mode().
+ uint8_t *const tmp_buf = get_buf_by_bd(xd, x->tmp_pred_bufs[0]);
- // The best RD found for the reference frame, among single reference modes.
- // Note that the 0-th element will contain a cut-off that is later used
- // to determine if we should skip a compound mode.
+ // The best RD found for the reference frame, among single reference modes.
+ // Note that the 0-th element will contain a cut-off that is later used
+ // to determine if we should skip a compound mode.
- int64_t ref_frame_rd[SINGLE_REF_FRAMES] = {
- INT64_MAX,
- INT64_MAX,
- INT64_MAX,
- INT64_MAX,
- INT64_MAX,
- INT64_MAX,
- INT64_MAX,
- INT64_MAX,
+ int64_t ref_frame_rd[SINGLE_REF_FRAMES] = {
+ INT64_MAX,
+ INT64_MAX,
+ INT64_MAX,
+ INT64_MAX,
+ INT64_MAX,
+ INT64_MAX,
+ INT64_MAX,
+ INT64_MAX,
#if CONFIG_TIP
- INT64_MAX
+ INT64_MAX
#endif // CONFIG_TIP
- };
+ };
- // Prepared stats used later to check if we could skip intra mode eval.
- int64_t inter_cost = -1;
- int64_t intra_cost = -1;
- // Need to tweak the threshold for hdres speed 0 & 1.
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
+ // Prepared stats used later to check if we could skip intra mode eval.
+ int64_t inter_cost = -1;
+ int64_t intra_cost = -1;
+ // Need to tweak the threshold for hdres speed 0 & 1.
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
- // Obtain the relevant tpl stats for pruning inter modes
- PruneInfoFromTpl inter_cost_info_from_tpl;
- if (cpi->sf.inter_sf.prune_inter_modes_based_on_tpl) {
- // x->tpl_keep_ref_frame[id] = 1 => no pruning in
- // prune_ref_by_selective_ref_frame()
- // x->tpl_keep_ref_frame[id] = 0 => ref frame can be pruned in
- // prune_ref_by_selective_ref_frame()
- // Populating valid_refs[idx] = 1 ensures that
- // 'inter_cost_info_from_tpl.best_inter_cost' does not correspond to a
- // pruned ref frame.
- int valid_refs[INTER_REFS_PER_FRAME] = { 0 };
+ // Obtain the relevant tpl stats for pruning inter modes
+ PruneInfoFromTpl inter_cost_info_from_tpl;
+ if (cpi->sf.inter_sf.prune_inter_modes_based_on_tpl) {
+ // x->tpl_keep_ref_frame[id] = 1 => no pruning in
+ // prune_ref_by_selective_ref_frame()
+ // x->tpl_keep_ref_frame[id] = 0 => ref frame can be pruned in
+ // prune_ref_by_selective_ref_frame()
+ // Populating valid_refs[idx] = 1 ensures that
+ // 'inter_cost_info_from_tpl.best_inter_cost' does not correspond to a
+ // pruned ref frame.
+ int valid_refs[INTER_REFS_PER_FRAME] = { 0 };
#if CONFIG_NEW_REF_SIGNALING
- for (MV_REFERENCE_FRAME frame = 0;
- frame < cm->ref_frames_info.num_total_refs; frame++) {
- const MV_REFERENCE_FRAME refs[2] = { frame, NONE_FRAME };
- valid_refs[frame] = x->tpl_keep_ref_frame[frame] ||
- !prune_ref_by_selective_ref_frame(cpi, x, refs);
- }
+ for (MV_REFERENCE_FRAME frame = 0;
+ frame < cm->ref_frames_info.num_total_refs; frame++) {
+ const MV_REFERENCE_FRAME refs[2] = { frame, NONE_FRAME };
+ valid_refs[frame] = x->tpl_keep_ref_frame[frame] ||
+ !prune_ref_by_selective_ref_frame(cpi, x, refs);
+ }
#else
for (MV_REFERENCE_FRAME frame = LAST_FRAME; frame < REF_FRAMES; frame++) {
const MV_REFERENCE_FRAME refs[2] = { frame, NONE_FRAME };
@@ -7730,119 +7322,117 @@
cpi, x, refs, cm->cur_frame->ref_display_order_hint);
}
#endif // CONFIG_NEW_REF_SIGNALING
- av1_zero(inter_cost_info_from_tpl);
- get_block_level_tpl_stats(cpi, bsize, mi_row, mi_col, valid_refs,
- &inter_cost_info_from_tpl);
- }
- const int do_pruning =
- (AOMMIN(cm->width, cm->height) > 480 && cpi->speed <= 1) ? 0 : 1;
- if (do_pruning && sf->intra_sf.skip_intra_in_interframe) {
- // Only consider full SB.
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
- const int tpl_bsize_1d = cpi->tpl_data.tpl_bsize_1d;
- const int len = (block_size_wide[sb_size] / tpl_bsize_1d) *
- (block_size_high[sb_size] / tpl_bsize_1d);
- SuperBlockEnc *sb_enc = &x->sb_enc;
- if (sb_enc->tpl_data_count == len) {
- const BLOCK_SIZE tpl_bsize = convert_length_to_bsize(tpl_bsize_1d);
- const int tpl_stride = sb_enc->tpl_stride;
- const int tplw = mi_size_wide[tpl_bsize];
- const int tplh = mi_size_high[tpl_bsize];
- const int nw = mi_size_wide[bsize] / tplw;
- const int nh = mi_size_high[bsize] / tplh;
- if (nw >= 1 && nh >= 1) {
- const int of_h = mi_row % mi_size_high[sb_size];
- const int of_w = mi_col % mi_size_wide[sb_size];
- const int start = of_h / tplh * tpl_stride + of_w / tplw;
+ av1_zero(inter_cost_info_from_tpl);
+ get_block_level_tpl_stats(cpi, bsize, mi_row, mi_col, valid_refs,
+ &inter_cost_info_from_tpl);
+ }
+ const int do_pruning =
+ (AOMMIN(cm->width, cm->height) > 480 && cpi->speed <= 1) ? 0 : 1;
+ if (do_pruning && sf->intra_sf.skip_intra_in_interframe) {
+ // Only consider full SB.
+ const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const int tpl_bsize_1d = cpi->tpl_data.tpl_bsize_1d;
+ const int len = (block_size_wide[sb_size] / tpl_bsize_1d) *
+ (block_size_high[sb_size] / tpl_bsize_1d);
+ SuperBlockEnc *sb_enc = &x->sb_enc;
+ if (sb_enc->tpl_data_count == len) {
+ const BLOCK_SIZE tpl_bsize = convert_length_to_bsize(tpl_bsize_1d);
+ const int tpl_stride = sb_enc->tpl_stride;
+ const int tplw = mi_size_wide[tpl_bsize];
+ const int tplh = mi_size_high[tpl_bsize];
+ const int nw = mi_size_wide[bsize] / tplw;
+ const int nh = mi_size_high[bsize] / tplh;
+ if (nw >= 1 && nh >= 1) {
+ const int of_h = mi_row % mi_size_high[sb_size];
+ const int of_w = mi_col % mi_size_wide[sb_size];
+ const int start = of_h / tplh * tpl_stride + of_w / tplw;
- for (int k = 0; k < nh; k++) {
- for (int l = 0; l < nw; l++) {
- inter_cost += sb_enc->tpl_inter_cost[start + k * tpl_stride + l];
- intra_cost += sb_enc->tpl_intra_cost[start + k * tpl_stride + l];
- }
+ for (int k = 0; k < nh; k++) {
+ for (int l = 0; l < nw; l++) {
+ inter_cost += sb_enc->tpl_inter_cost[start + k * tpl_stride + l];
+ intra_cost += sb_enc->tpl_intra_cost[start + k * tpl_stride + l];
}
- inter_cost /= nw * nh;
- intra_cost /= nw * nh;
}
+ inter_cost /= nw * nh;
+ intra_cost /= nw * nh;
}
}
+ }
- // Initialize best mode stats for winner mode processing
- av1_zero(x->winner_mode_stats);
- x->winner_mode_count = 0;
- const MV_REFERENCE_FRAME init_refs[2] = { -1, -1 };
- store_winner_mode_stats(&cpi->common, x, mbmi, NULL, NULL, NULL, init_refs,
- MODE_INVALID, NULL, bsize, best_rd_so_far,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, 0);
+ // Initialize best mode stats for winner mode processing
+ av1_zero(x->winner_mode_stats);
+ x->winner_mode_count = 0;
+ const MV_REFERENCE_FRAME init_refs[2] = { -1, -1 };
+ store_winner_mode_stats(&cpi->common, x, mbmi, NULL, NULL, NULL, init_refs,
+ MODE_INVALID, NULL, bsize, best_rd_so_far,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type, 0);
- int mode_thresh_mul_fact = (1 << MODE_THRESH_QBITS);
- if (sf->inter_sf.prune_inter_modes_if_skippable) {
- // Higher multiplication factor values for lower quantizers.
- mode_thresh_mul_fact = mode_threshold_mul_factor[x->qindex];
- }
+ int mode_thresh_mul_fact = (1 << MODE_THRESH_QBITS);
+ if (sf->inter_sf.prune_inter_modes_if_skippable) {
+ // Higher multiplication factor values for lower quantizers.
+ mode_thresh_mul_fact = mode_threshold_mul_factor[x->qindex];
+ }
- // Initialize arguments for mode loop speed features
- InterModeSFArgs sf_args = { &args.skip_motion_mode,
- &mode_skip_mask,
- &search_state,
- skip_ref_frame_mask,
- 0,
- mode_thresh_mul_fact,
- &num_single_modes_processed,
- 0 };
+ // Initialize arguments for mode loop speed features
+ InterModeSFArgs sf_args = { &args.skip_motion_mode,
+ &mode_skip_mask,
+ &search_state,
+ skip_ref_frame_mask,
+ 0,
+ mode_thresh_mul_fact,
+ &num_single_modes_processed,
+ 0 };
- // This is the main loop of this function. It loops over all possible modes
- // and calls handle_inter_mode() to compute the RD for each.
- // Here midx is just an iterator index that should not be used by itself
- // except to keep track of the number of modes searched. It should be used
- // with av1_default_mode_order to get the enum that defines the mode, which
- // can be used with av1_mode_defs to get the prediction mode and the ref
- // frames.
+ // This is the main loop of this function. It loops over all possible modes
+ // and calls handle_inter_mode() to compute the RD for each.
+ // Here midx is just an iterator index that should not be used by itself
+ // except to keep track of the number of modes searched. It should be used
+ // with av1_default_mode_order to get the enum that defines the mode, which
+ // can be used with av1_mode_defs to get the prediction mode and the ref
+ // frames.
#if CONFIG_NEW_REF_SIGNALING
- for (PREDICTION_MODE this_mode = 0; this_mode < MB_MODE_COUNT;
- ++this_mode) {
+ for (PREDICTION_MODE this_mode = 0; this_mode < MB_MODE_COUNT; ++this_mode) {
#if CONFIG_TIP
- for (MV_REFERENCE_FRAME rf = NONE_FRAME;
- rf < cm->ref_frames_info.num_total_refs + 1; ++rf) {
- const MV_REFERENCE_FRAME ref_frame =
- (rf == NONE_FRAME)
- ? INTRA_FRAME
- : ((rf == cm->ref_frames_info.num_total_refs) ? TIP_FRAME : rf);
- if (is_tip_ref_frame(ref_frame) &&
- (!is_tip_allowed_bsize(bsize) || !is_tip_mode(this_mode) ||
- !cm->features.tip_frame_mode))
- continue;
+ for (MV_REFERENCE_FRAME rf = NONE_FRAME;
+ rf < cm->ref_frames_info.num_total_refs + 1; ++rf) {
+ const MV_REFERENCE_FRAME ref_frame =
+ (rf == NONE_FRAME)
+ ? INTRA_FRAME
+ : ((rf == cm->ref_frames_info.num_total_refs) ? TIP_FRAME : rf);
+ if (is_tip_ref_frame(ref_frame) &&
+ (!is_tip_allowed_bsize(bsize) || !is_tip_mode(this_mode) ||
+ !cm->features.tip_frame_mode))
+ continue;
#else
for (MV_REFERENCE_FRAME rf = NONE_FRAME;
rf < cm->ref_frames_info.num_total_refs; ++rf) {
const MV_REFERENCE_FRAME ref_frame =
(rf == NONE_FRAME) ? INTRA_FRAME : rf;
#endif // CONFIG_TIP
- if (this_mode < INTRA_MODE_END && ref_frame != INTRA_FRAME) continue;
- if (this_mode >= INTRA_MODE_END && ref_frame == INTRA_FRAME) continue;
- for (MV_REFERENCE_FRAME second_rf = NONE_FRAME;
- second_rf < cm->ref_frames_info.num_total_refs; ++second_rf) {
- MV_REFERENCE_FRAME second_ref_frame = second_rf;
- if (second_ref_frame != NONE_FRAME &&
- this_mode < COMP_INTER_MODE_START)
- continue;
- if (this_mode >= COMP_INTER_MODE_START &&
- this_mode < COMP_INTER_MODE_END && second_ref_frame == NONE_FRAME)
- continue;
- if (is_inter_ref_frame(second_ref_frame) &&
- second_ref_frame <= ref_frame)
- continue;
+ if (this_mode < INTRA_MODE_END && ref_frame != INTRA_FRAME) continue;
+ if (this_mode >= INTRA_MODE_END && ref_frame == INTRA_FRAME) continue;
+ for (MV_REFERENCE_FRAME second_rf = NONE_FRAME;
+ second_rf < cm->ref_frames_info.num_total_refs; ++second_rf) {
+ MV_REFERENCE_FRAME second_ref_frame = second_rf;
+ if (second_ref_frame != NONE_FRAME && this_mode < COMP_INTER_MODE_START)
+ continue;
+ if (this_mode >= COMP_INTER_MODE_START &&
+ this_mode < COMP_INTER_MODE_END && second_ref_frame == NONE_FRAME)
+ continue;
+ if (is_inter_ref_frame(second_ref_frame) &&
+ second_ref_frame <= ref_frame)
+ continue;
#if CONFIG_TIP
- if (is_tip_ref_frame(ref_frame) && second_ref_frame != NONE_FRAME)
- continue;
+ if (is_tip_ref_frame(ref_frame) && second_ref_frame != NONE_FRAME)
+ continue;
#endif // CONFIG_TIP
- const MV_REFERENCE_FRAME ref_frames[2] = { ref_frame,
- second_ref_frame };
+ const MV_REFERENCE_FRAME ref_frames[2] = { ref_frame,
+ second_ref_frame };
- const int is_single_pred =
- ref_frame != INTRA_FRAME && second_ref_frame == NONE_FRAME;
+ const int is_single_pred =
+ ref_frame != INTRA_FRAME && second_ref_frame == NONE_FRAME;
#else
for (THR_MODES midx = THR_MODE_START; midx < THR_MODE_END; ++midx) {
@@ -7862,16 +7452,16 @@
const int is_single_pred =
is_inter_ref_frame(ref_frame) && second_ref_frame == NONE_FRAME;
#endif // CONFIG_NEW_REF_SIGNALING
- const int comp_pred = is_inter_ref_frame(second_ref_frame);
+ const int comp_pred = is_inter_ref_frame(second_ref_frame);
#if CONFIG_IBC_SR_EXT
- init_mbmi(mbmi, this_mode, ref_frames, cm, xd
+ init_mbmi(mbmi, this_mode, ref_frames, cm, xd
#if CONFIG_FLEX_MVRES
- ,
- xd->sbi
+ ,
+ xd->sbi
#endif
- );
+ );
#else
init_mbmi(mbmi, this_mode, ref_frames, cm
#if CONFIG_FLEX_MVRES
@@ -7882,310 +7472,306 @@
#endif // CONFIG_IBC_SR_EXT
#if CONFIG_FLEX_MVRES
- set_mv_precision(mbmi, mbmi->max_mv_precision);
- if (is_pb_mv_precision_active(cm, mbmi, bsize))
- set_most_probable_mv_precision(cm, mbmi, bsize);
+ set_mv_precision(mbmi, mbmi->max_mv_precision);
+ if (is_pb_mv_precision_active(cm, mbmi, bsize))
+ set_most_probable_mv_precision(cm, mbmi, bsize);
#endif
#if CONFIG_OPTFLOW_REFINEMENT
- // Optical flow compound modes are only enabled with enable_order_hint
- // and when prediction is bi-directional
- if (this_mode >= NEAR_NEARMV_OPTFLOW &&
- (!cm->seq_params.order_hint_info.enable_order_hint ||
- !has_second_ref(mbmi) || !is_opfl_refine_allowed(cm, mbmi)))
- continue;
- // In REFINE_ALL, optical flow refinement has been applied to regular
- // compound modes.
- if (cm->features.opfl_refine_type == REFINE_ALL &&
- (this_mode >= NEAR_NEARMV_OPTFLOW ||
- this_mode == GLOBAL_GLOBALMV))
- continue;
+ // Optical flow compound modes are only enabled with enable_order_hint
+ // and when prediction is bi-directional
+ if (this_mode >= NEAR_NEARMV_OPTFLOW &&
+ (!cm->seq_params.order_hint_info.enable_order_hint ||
+ !has_second_ref(mbmi) || !is_opfl_refine_allowed(cm, mbmi)))
+ continue;
+ // In REFINE_ALL, optical flow refinement has been applied to regular
+ // compound modes.
+ if (cm->features.opfl_refine_type == REFINE_ALL &&
+ (this_mode >= NEAR_NEARMV_OPTFLOW || this_mode == GLOBAL_GLOBALMV))
+ continue;
#endif // CONFIG_OPTFLOW_REFINEMENT
- txfm_info->skip_txfm = 0;
- num_single_modes_processed += is_single_pred;
- set_ref_ptrs(cm, xd, ref_frame, second_ref_frame);
+ txfm_info->skip_txfm = 0;
+ num_single_modes_processed += is_single_pred;
+ set_ref_ptrs(cm, xd, ref_frame, second_ref_frame);
- // Apply speed features to decide if this inter mode can be skipped
- if (skip_inter_mode(cpi, x, bsize, ref_frame_rd,
+ // Apply speed features to decide if this inter mode can be skipped
+ if (skip_inter_mode(cpi, x, bsize, ref_frame_rd,
#if CONFIG_NEW_REF_SIGNALING
- this_mode, ref_frames,
+ this_mode, ref_frames,
#else
midx,
#endif // CONFIG_NEW_REF_SIGNALING
- &sf_args))
- continue;
+ &sf_args))
+ continue;
#if IMPROVED_AMVD
- if (this_mode == AMVDNEWMV && cm->seq_params.enable_adaptive_mvd == 0)
- continue;
+ if (this_mode == AMVDNEWMV && cm->seq_params.enable_adaptive_mvd == 0)
+ continue;
#endif // IMPROVED_AMVD
- // Select prediction reference frames.
- for (i = 0; i < num_planes; i++) {
+ // Select prediction reference frames.
+ for (i = 0; i < num_planes; i++) {
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- xd->plane[i].pre[0] = yv12_mb[COMPACT_INDEX0_NRS(ref_frame)][i];
- if (comp_pred)
- xd->plane[i].pre[1] =
- yv12_mb[COMPACT_INDEX0_NRS(second_ref_frame)][i];
+ xd->plane[i].pre[0] = yv12_mb[COMPACT_INDEX0_NRS(ref_frame)][i];
+ if (comp_pred)
+ xd->plane[i].pre[1] =
+ yv12_mb[COMPACT_INDEX0_NRS(second_ref_frame)][i];
#else
xd->plane[i].pre[0] = yv12_mb[ref_frame][i];
if (comp_pred) xd->plane[i].pre[1] = yv12_mb[second_ref_frame][i];
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- }
+ }
#if CONFIG_FORWARDSKIP
- mbmi->fsc_mode[PLANE_TYPE_Y] = 0;
- mbmi->fsc_mode[PLANE_TYPE_UV] = 0;
+ mbmi->fsc_mode[PLANE_TYPE_Y] = 0;
+ mbmi->fsc_mode[PLANE_TYPE_UV] = 0;
#endif // CONFIG_FORWARDSKIP
- mbmi->angle_delta[PLANE_TYPE_Y] = 0;
- mbmi->angle_delta[PLANE_TYPE_UV] = 0;
- mbmi->filter_intra_mode_info.use_filter_intra = 0;
- mbmi->ref_mv_idx = 0;
+ mbmi->angle_delta[PLANE_TYPE_Y] = 0;
+ mbmi->angle_delta[PLANE_TYPE_UV] = 0;
+ mbmi->filter_intra_mode_info.use_filter_intra = 0;
+ mbmi->ref_mv_idx = 0;
- const int64_t ref_best_rd = search_state.best_rd;
- RD_STATS rd_stats, rd_stats_y, rd_stats_uv;
- av1_init_rd_stats(&rd_stats);
+ const int64_t ref_best_rd = search_state.best_rd;
+ RD_STATS rd_stats, rd_stats_y, rd_stats_uv;
+ av1_init_rd_stats(&rd_stats);
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- const int ref_frame_index = COMPACT_INDEX0_NRS(ref_frame);
+ const int ref_frame_index = COMPACT_INDEX0_NRS(ref_frame);
#else
const int ref_frame_index = ref_frame;
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- const int ref_frame_cost =
- comp_pred ? ref_costs_comp[ref_frame][second_ref_frame]
- : ref_costs_single[ref_frame_index];
+ const int ref_frame_cost =
+ comp_pred ? ref_costs_comp[ref_frame][second_ref_frame]
+ : ref_costs_single[ref_frame_index];
- const int compmode_cost =
- (is_comp_ref_allowed(mbmi->sb_type[PLANE_TYPE_Y])
+ const int compmode_cost =
+ (is_comp_ref_allowed(mbmi->sb_type[PLANE_TYPE_Y])
#if CONFIG_TIP
- && !is_tip_ref_frame(ref_frame)
+ && !is_tip_ref_frame(ref_frame)
#endif // CONFIG_TIP
- )
- ? comp_inter_cost[comp_pred]
- : 0;
- const int real_compmode_cost =
- cm->current_frame.reference_mode == REFERENCE_MODE_SELECT
- ? compmode_cost
- : 0;
- // Point to variables that are maintained between loop iterations
- args.single_newmv = search_state.single_newmv;
- args.single_newmv_rate = search_state.single_newmv_rate;
- args.single_newmv_valid = search_state.single_newmv_valid;
- args.single_comp_cost = real_compmode_cost;
- args.ref_frame_cost = ref_frame_cost;
+ )
+ ? comp_inter_cost[comp_pred]
+ : 0;
+ const int real_compmode_cost =
+ cm->current_frame.reference_mode == REFERENCE_MODE_SELECT
+ ? compmode_cost
+ : 0;
+ // Point to variables that are maintained between loop iterations
+ args.single_newmv = search_state.single_newmv;
+ args.single_newmv_rate = search_state.single_newmv_rate;
+ args.single_newmv_valid = search_state.single_newmv_valid;
+ args.single_comp_cost = real_compmode_cost;
+ args.ref_frame_cost = ref_frame_cost;
- int64_t skip_rd[2] = { search_state.best_skip_rd[0],
- search_state.best_skip_rd[1] };
- int64_t this_rd = handle_inter_mode(
- cpi, tile_data, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv,
- &args, ref_best_rd, tmp_buf, &x->comp_rd_buffer, &best_est_rd,
- do_tx_search, inter_modes_info, &motion_mode_cand, skip_rd,
- &inter_cost_info_from_tpl);
+ int64_t skip_rd[2] = { search_state.best_skip_rd[0],
+ search_state.best_skip_rd[1] };
+ int64_t this_rd = handle_inter_mode(
+ cpi, tile_data, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv,
+ &args, ref_best_rd, tmp_buf, &x->comp_rd_buffer, &best_est_rd,
+ do_tx_search, inter_modes_info, &motion_mode_cand, skip_rd,
+ &inter_cost_info_from_tpl);
- if (sf->inter_sf.prune_comp_search_by_single_result > 0 &&
- is_inter_singleref_mode(this_mode)) {
- collect_single_states(cm, x, &search_state, mbmi);
- }
+ if (sf->inter_sf.prune_comp_search_by_single_result > 0 &&
+ is_inter_singleref_mode(this_mode)) {
+ collect_single_states(cm, x, &search_state, mbmi);
+ }
- if (sf->inter_sf.prune_comp_using_best_single_mode_ref > 0 &&
- is_inter_singleref_mode(this_mode))
- update_best_single_mode(&search_state, this_mode, ref_frame,
- this_rd);
+ if (sf->inter_sf.prune_comp_using_best_single_mode_ref > 0 &&
+ is_inter_singleref_mode(this_mode))
+ update_best_single_mode(&search_state, this_mode, ref_frame, this_rd);
- if (this_rd == INT64_MAX) continue;
- if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
- rd_stats_y.rate = 0;
- rd_stats_uv.rate = 0;
- }
+ if (this_rd == INT64_MAX) continue;
+ if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
+ rd_stats_y.rate = 0;
+ rd_stats_uv.rate = 0;
+ }
- if (sf->inter_sf.prune_compound_using_single_ref && is_single_pred &&
- this_rd < ref_frame_rd[ref_frame_index]) {
- ref_frame_rd[ref_frame_index] = this_rd;
- }
+ if (sf->inter_sf.prune_compound_using_single_ref && is_single_pred &&
+ this_rd < ref_frame_rd[ref_frame_index]) {
+ ref_frame_rd[ref_frame_index] = this_rd;
+ }
- // Did this mode help, i.e., is it the new best mode
- if (this_rd < search_state.best_rd) {
- assert(IMPLIES(comp_pred, cm->current_frame.reference_mode !=
- SINGLE_REFERENCE));
+ // Did this mode help, i.e., is it the new best mode
+ if (this_rd < search_state.best_rd) {
+ assert(IMPLIES(comp_pred,
+ cm->current_frame.reference_mode != SINGLE_REFERENCE));
#if CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- search_state.best_pred_sse =
- x->pred_sse[COMPACT_INDEX0_NRS(ref_frame)];
+ search_state.best_pred_sse =
+ x->pred_sse[COMPACT_INDEX0_NRS(ref_frame)];
#else
search_state.best_pred_sse = x->pred_sse[ref_frame];
#endif // CONFIG_NEW_REF_SIGNALING || CONFIG_TIP
- update_search_state(&search_state, rd_cost, ctx, &rd_stats,
- &rd_stats_y, &rd_stats_uv, this_mode, x,
- do_tx_search);
- if (do_tx_search) search_state.best_skip_rd[0] = skip_rd[0];
- search_state.best_skip_rd[1] = skip_rd[1];
- }
- if (cpi->sf.winner_mode_sf.motion_mode_for_winner_cand) {
- // Add this mode to motion mode candidate list for motion mode
- // search if using motion_mode_for_winner_cand speed feature
- handle_winner_cand(mbmi, &best_motion_mode_cands,
- max_winner_motion_mode_cand, this_rd,
- &motion_mode_cand, args.skip_motion_mode);
- }
+ update_search_state(&search_state, rd_cost, ctx, &rd_stats,
+ &rd_stats_y, &rd_stats_uv, this_mode, x,
+ do_tx_search);
+ if (do_tx_search) search_state.best_skip_rd[0] = skip_rd[0];
+ search_state.best_skip_rd[1] = skip_rd[1];
+ }
+ if (cpi->sf.winner_mode_sf.motion_mode_for_winner_cand) {
+ // Add this mode to motion mode candidate list for motion mode
+ // search if using motion_mode_for_winner_cand speed feature
+ handle_winner_cand(mbmi, &best_motion_mode_cands,
+ max_winner_motion_mode_cand, this_rd,
+ &motion_mode_cand, args.skip_motion_mode);
+ }
- /* keep record of best compound/single-only prediction */
- record_best_compound(cm->current_frame.reference_mode, &rd_stats,
- comp_pred, x->rdmult, &search_state,
- compmode_cost);
+ /* keep record of best compound/single-only prediction */
+ record_best_compound(cm->current_frame.reference_mode, &rd_stats,
+ comp_pred, x->rdmult, &search_state,
+ compmode_cost);
#if CONFIG_NEW_REF_SIGNALING
- } // end of ref1 loop
- } // end of ref0 loop
-#endif // CONFIG_NEW_REF_SIGNALING
- } // end of mode loop
+ } // end of ref1 loop
+ } // end of ref0 loop
+#endif // CONFIG_NEW_REF_SIGNALING
+ } // end of mode loop
- if (cpi->sf.winner_mode_sf.motion_mode_for_winner_cand) {
- // For the single ref winner candidates, evaluate other motion modes (non
- // simple translation).
- evaluate_motion_mode_for_winner_candidates(
- cpi, x, rd_cost, &args, tile_data, ctx, yv12_mb,
- &best_motion_mode_cands, do_tx_search, bsize, &best_est_rd,
- &search_state);
- }
+ if (cpi->sf.winner_mode_sf.motion_mode_for_winner_cand) {
+ // For the single ref winner candidates, evaluate other motion modes (non
+ // simple translation).
+ evaluate_motion_mode_for_winner_candidates(
+ cpi, x, rd_cost, &args, tile_data, ctx, yv12_mb,
+ &best_motion_mode_cands, do_tx_search, bsize, &best_est_rd,
+ &search_state);
+ }
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, do_tx_search_time);
+ start_timing(cpi, do_tx_search_time);
#endif
- if (do_tx_search != 1) {
- // A full tx search has not yet been done, do tx search for
- // top mode candidates
- tx_search_best_inter_candidates(cpi, tile_data, x, best_rd_so_far, bsize,
- yv12_mb, mi_row, mi_col, &search_state,
- rd_cost, ctx);
- }
+ if (do_tx_search != 1) {
+ // A full tx search has not yet been done, do tx search for
+ // top mode candidates
+ tx_search_best_inter_candidates(cpi, tile_data, x, best_rd_so_far, bsize,
+ yv12_mb, mi_row, mi_col, &search_state,
+ rd_cost, ctx);
+ }
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, do_tx_search_time);
+ end_timing(cpi, do_tx_search_time);
#endif
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, handle_intra_mode_time);
+ start_timing(cpi, handle_intra_mode_time);
#endif
- // Gate intra mode evaluation if best of inter is skip except when source
- // variance is extremely low
- if (sf->intra_sf.skip_intra_in_interframe &&
- (x->source_variance > sf->intra_sf.src_var_thresh_intra_skip)) {
- if (inter_cost >= 0 && intra_cost >= 0) {
- aom_clear_system_state();
- const NN_CONFIG *nn_config = (AOMMIN(cm->width, cm->height) <= 480)
- ? &av1_intrap_nn_config
- : &av1_intrap_hd_nn_config;
- float nn_features[6];
- float scores[2] = { 0.0f };
- float probs[2] = { 0.0f };
- nn_features[0] = (float)search_state.best_mbmode
- .skip_txfm[xd->tree_type != CHROMA_PART ? 0 : 1];
- nn_features[1] = (float)mi_size_wide_log2[bsize];
- nn_features[2] = (float)mi_size_high_log2[bsize];
- nn_features[3] = (float)intra_cost;
- nn_features[4] = (float)inter_cost;
- const int ac_q = av1_ac_quant_QTX(x->qindex, 0, xd->bd);
- const int ac_q_max = av1_ac_quant_QTX(255, 0, xd->bd);
- nn_features[5] = (float)(ac_q_max / ac_q);
+ // Gate intra mode evaluation if best of inter is skip except when source
+ // variance is extremely low
+ if (sf->intra_sf.skip_intra_in_interframe &&
+ (x->source_variance > sf->intra_sf.src_var_thresh_intra_skip)) {
+ if (inter_cost >= 0 && intra_cost >= 0) {
+ aom_clear_system_state();
+ const NN_CONFIG *nn_config = (AOMMIN(cm->width, cm->height) <= 480)
+ ? &av1_intrap_nn_config
+ : &av1_intrap_hd_nn_config;
+ float nn_features[6];
+ float scores[2] = { 0.0f };
+ float probs[2] = { 0.0f };
+ nn_features[0] = (float)search_state.best_mbmode
+ .skip_txfm[xd->tree_type != CHROMA_PART ? 0 : 1];
+ nn_features[1] = (float)mi_size_wide_log2[bsize];
+ nn_features[2] = (float)mi_size_high_log2[bsize];
+ nn_features[3] = (float)intra_cost;
+ nn_features[4] = (float)inter_cost;
+ const int ac_q = av1_ac_quant_QTX(x->qindex, 0, xd->bd);
+ const int ac_q_max = av1_ac_quant_QTX(255, 0, xd->bd);
+ nn_features[5] = (float)(ac_q_max / ac_q);
- av1_nn_predict(nn_features, nn_config, 1, scores);
- aom_clear_system_state();
- av1_nn_softmax(scores, probs, 2);
+ av1_nn_predict(nn_features, nn_config, 1, scores);
+ aom_clear_system_state();
+ av1_nn_softmax(scores, probs, 2);
- if (probs[1] > 0.8)
- search_state.intra_search_state.skip_intra_modes = 1;
- } else if ((search_state.best_mbmode
- .skip_txfm[xd->tree_type == CHROMA_PART]) &&
- (sf->intra_sf.skip_intra_in_interframe >= 2)) {
- search_state.intra_search_state.skip_intra_modes = 1;
- }
+ if (probs[1] > 0.8) search_state.intra_search_state.skip_intra_modes = 1;
+ } else if ((search_state.best_mbmode
+ .skip_txfm[xd->tree_type == CHROMA_PART]) &&
+ (sf->intra_sf.skip_intra_in_interframe >= 2)) {
+ search_state.intra_search_state.skip_intra_modes = 1;
}
+ }
#if CONFIG_NEW_REF_SIGNALING
- const unsigned int intra_ref_frame_cost =
- ref_costs_single[INTRA_FRAME_INDEX];
+ const unsigned int intra_ref_frame_cost = ref_costs_single[INTRA_FRAME_INDEX];
#else
const unsigned int intra_ref_frame_cost = ref_costs_single[INTRA_FRAME];
#endif // CONFIG_NEW_REF_SIGNALING
- int64_t best_model_rd = INT64_MAX;
- int64_t top_intra_model_rd[TOP_INTRA_MODEL_COUNT];
- for (i = 0; i < TOP_INTRA_MODEL_COUNT; i++) {
- top_intra_model_rd[i] = INT64_MAX;
- }
+ int64_t best_model_rd = INT64_MAX;
+ int64_t top_intra_model_rd[TOP_INTRA_MODEL_COUNT];
+ for (i = 0; i < TOP_INTRA_MODEL_COUNT; i++) {
+ top_intra_model_rd[i] = INT64_MAX;
+ }
#if CONFIG_AIMC
- get_y_intra_mode_set(mbmi, xd);
+ get_y_intra_mode_set(mbmi, xd);
#endif // CONFIG_AIMC
#if CONFIG_FORWARDSKIP
- for (int fsc_mode = 0;
- fsc_mode < (allow_fsc_intra(cm, xd, bsize, mbmi) ? FSC_MODES : 1);
- fsc_mode++) {
+ for (int fsc_mode = 0;
+ fsc_mode < (allow_fsc_intra(cm, xd, bsize, mbmi) ? FSC_MODES : 1);
+ fsc_mode++) {
#endif // CONFIG_FORWARDSKIP
- uint8_t enable_mrls_flag = cm->seq_params.enable_mrls
+ uint8_t enable_mrls_flag = cm->seq_params.enable_mrls
#if CONFIG_FORWARDSKIP
- && !fsc_mode
+ && !fsc_mode
#endif // CONFIG_FORWARDSKIP
- ;
- for (int mrl_index = 0;
- mrl_index < (enable_mrls_flag ? MRL_LINE_NUMBER : 1); mrl_index++) {
+ ;
+ for (int mrl_index = 0;
+ mrl_index < (enable_mrls_flag ? MRL_LINE_NUMBER : 1); mrl_index++) {
#if CONFIG_FORWARDSKIP
- mbmi->fsc_mode[xd->tree_type == CHROMA_PART] = fsc_mode;
+ mbmi->fsc_mode[xd->tree_type == CHROMA_PART] = fsc_mode;
#endif // CONFIG_FORWARDSKIP
- mbmi->mrl_index = mrl_index;
- for (int mode_idx = INTRA_MODE_START; mode_idx < LUMA_MODE_COUNT;
- ++mode_idx) {
- if (sf->intra_sf.skip_intra_in_interframe &&
- search_state.intra_search_state.skip_intra_modes)
- break;
+ mbmi->mrl_index = mrl_index;
+ for (int mode_idx = INTRA_MODE_START; mode_idx < LUMA_MODE_COUNT;
+ ++mode_idx) {
+ if (sf->intra_sf.skip_intra_in_interframe &&
+ search_state.intra_search_state.skip_intra_modes)
+ break;
#if CONFIG_AIMC
- mbmi->y_mode_idx = mode_idx;
- mbmi->joint_y_mode_delta_angle = mbmi->y_intra_mode_list[mode_idx];
- set_y_mode_and_delta_angle(mbmi->joint_y_mode_delta_angle, mbmi);
+ mbmi->y_mode_idx = mode_idx;
+ mbmi->joint_y_mode_delta_angle = mbmi->y_intra_mode_list[mode_idx];
+ set_y_mode_and_delta_angle(mbmi->joint_y_mode_delta_angle, mbmi);
#else
set_y_mode_and_delta_angle(mode_idx, mbmi);
#endif // CONFIG_AIMC
- if ((!cpi->oxcf.intra_mode_cfg.enable_smooth_intra ||
- cpi->sf.intra_sf.disable_smooth_intra) &&
- (mbmi->mode == SMOOTH_PRED || mbmi->mode == SMOOTH_H_PRED ||
- mbmi->mode == SMOOTH_V_PRED))
- continue;
- if (!cpi->oxcf.intra_mode_cfg.enable_paeth_intra &&
- mbmi->mode == PAETH_PRED)
- continue;
+ if ((!cpi->oxcf.intra_mode_cfg.enable_smooth_intra ||
+ cpi->sf.intra_sf.disable_smooth_intra) &&
+ (mbmi->mode == SMOOTH_PRED || mbmi->mode == SMOOTH_H_PRED ||
+ mbmi->mode == SMOOTH_V_PRED))
+ continue;
+ if (!cpi->oxcf.intra_mode_cfg.enable_paeth_intra &&
+ mbmi->mode == PAETH_PRED)
+ continue;
#if !CONFIG_AIMC
- if (av1_is_directional_mode(mbmi->mode) &&
- av1_use_angle_delta(bsize) == 0 &&
- mbmi->angle_delta[PLANE_TYPE_Y] != 0)
- continue;
+ if (av1_is_directional_mode(mbmi->mode) &&
+ av1_use_angle_delta(bsize) == 0 &&
+ mbmi->angle_delta[PLANE_TYPE_Y] != 0)
+ continue;
#endif // !CONFIG_AIMC
- if (mbmi->mrl_index > 0 && av1_is_directional_mode(mbmi->mode) == 0) {
- continue;
- }
+ if (mbmi->mrl_index > 0 && av1_is_directional_mode(mbmi->mode) == 0) {
+ continue;
+ }
#if CONFIG_FORWARDSKIP
- if (!allow_fsc_intra(cm, xd, bsize, mbmi) &&
- mbmi->fsc_mode[PLANE_TYPE_Y] > 0) {
- continue;
- }
- if (mbmi->mrl_index > 0 && mbmi->fsc_mode[PLANE_TYPE_Y]) {
- continue;
- }
+ if (!allow_fsc_intra(cm, xd, bsize, mbmi) &&
+ mbmi->fsc_mode[PLANE_TYPE_Y] > 0) {
+ continue;
+ }
+ if (mbmi->mrl_index > 0 && mbmi->fsc_mode[PLANE_TYPE_Y]) {
+ continue;
+ }
#if !CONFIG_AIMC
- if (mbmi->angle_delta[PLANE_TYPE_Y] && mbmi->fsc_mode[PLANE_TYPE_Y]) {
- continue;
- }
- if (mbmi->angle_delta[PLANE_TYPE_UV] &&
- mbmi->fsc_mode[xd->tree_type == CHROMA_PART]) {
- continue;
- }
+ if (mbmi->angle_delta[PLANE_TYPE_Y] && mbmi->fsc_mode[PLANE_TYPE_Y]) {
+ continue;
+ }
+ if (mbmi->angle_delta[PLANE_TYPE_UV] &&
+ mbmi->fsc_mode[xd->tree_type == CHROMA_PART]) {
+ continue;
+ }
#endif // CONFIG_AIMC
#endif // CONFIG_FORWARDSKIP
- const PREDICTION_MODE this_mode = mbmi->mode;
+ const PREDICTION_MODE this_mode = mbmi->mode;
#if CONFIG_NEW_REF_SIGNALING
- MV_REFERENCE_FRAME refs[2] = { INTRA_FRAME, NONE_FRAME };
+ MV_REFERENCE_FRAME refs[2] = { INTRA_FRAME, NONE_FRAME };
#else
THR_MODES mode_enum = mbmi->mode + THR_DC;
MV_REFERENCE_FRAME refs[2] = { av1_mode_defs[mode_enum].ref_frame[0],
@@ -8195,12 +7781,12 @@
#endif // CONFIG_NEW_REF_SIGNALING
#if CONFIG_IBC_SR_EXT
- init_mbmi(mbmi, this_mode, refs, cm, xd
+ init_mbmi(mbmi, this_mode, refs, cm, xd
#if CONFIG_FLEX_MVRES
- ,
- xd->sbi
+ ,
+ xd->sbi
#endif
- );
+ );
#else
init_mbmi(mbmi, this_mode, refs, cm
#if CONFIG_FLEX_MVRES
@@ -8209,85 +7795,84 @@
#endif
);
#endif // CONFIG_IBC_SR_EXT
- txfm_info->skip_txfm = 0;
+ txfm_info->skip_txfm = 0;
- RD_STATS intra_rd_stats, intra_rd_stats_y, intra_rd_stats_uv;
- intra_rd_stats.rdcost = av1_handle_intra_mode(
- &search_state.intra_search_state, cpi, x, bsize,
- intra_ref_frame_cost, ctx, &intra_rd_stats, &intra_rd_stats_y,
- &intra_rd_stats_uv, search_state.best_rd,
- &search_state.best_intra_rd, &best_model_rd, top_intra_model_rd);
+ RD_STATS intra_rd_stats, intra_rd_stats_y, intra_rd_stats_uv;
+ intra_rd_stats.rdcost = av1_handle_intra_mode(
+ &search_state.intra_search_state, cpi, x, bsize,
+ intra_ref_frame_cost, ctx, &intra_rd_stats, &intra_rd_stats_y,
+ &intra_rd_stats_uv, search_state.best_rd,
+ &search_state.best_intra_rd, &best_model_rd, top_intra_model_rd);
- // Collect mode stats for multiwinner mode processing
- const int txfm_search_done = 1;
- store_winner_mode_stats(&cpi->common, x, mbmi, &intra_rd_stats,
- &intra_rd_stats_y, &intra_rd_stats_uv, refs,
- this_mode, NULL, bsize, intra_rd_stats.rdcost,
- cpi->sf.winner_mode_sf.multi_winner_mode_type,
- txfm_search_done);
- if (intra_rd_stats.rdcost < search_state.best_rd) {
- update_search_state(&search_state, rd_cost, ctx, &intra_rd_stats,
- &intra_rd_stats_y, &intra_rd_stats_uv,
- this_mode, x, txfm_search_done);
- }
+ // Collect mode stats for multiwinner mode processing
+ const int txfm_search_done = 1;
+ store_winner_mode_stats(&cpi->common, x, mbmi, &intra_rd_stats,
+ &intra_rd_stats_y, &intra_rd_stats_uv, refs,
+ this_mode, NULL, bsize, intra_rd_stats.rdcost,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type,
+ txfm_search_done);
+ if (intra_rd_stats.rdcost < search_state.best_rd) {
+ update_search_state(&search_state, rd_cost, ctx, &intra_rd_stats,
+ &intra_rd_stats_y, &intra_rd_stats_uv, this_mode,
+ x, txfm_search_done);
}
-#if CONFIG_FLEX_MVRES
- set_mv_precision(mbmi, mbmi->max_mv_precision);
-#endif
}
-#if CONFIG_FORWARDSKIP
+#if CONFIG_FLEX_MVRES
+ set_mv_precision(mbmi, mbmi->max_mv_precision);
+#endif
}
+#if CONFIG_FORWARDSKIP
+ }
#endif // CONFIG_FORWARDSKIP
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, handle_intra_mode_time);
+ end_timing(cpi, handle_intra_mode_time);
#endif
- int winner_mode_count = cpi->sf.winner_mode_sf.multi_winner_mode_type
- ? x->winner_mode_count
- : 1;
- // In effect only when fast tx search speed features are enabled.
- refine_winner_mode_tx(cpi, x, rd_cost, bsize, ctx,
- &search_state.best_mbmode, yv12_mb,
- search_state.best_rate_y, search_state.best_rate_uv,
- &search_state.best_skip2, winner_mode_count);
+ int winner_mode_count =
+ cpi->sf.winner_mode_sf.multi_winner_mode_type ? x->winner_mode_count : 1;
+ // In effect only when fast tx search speed features are enabled.
+ refine_winner_mode_tx(cpi, x, rd_cost, bsize, ctx, &search_state.best_mbmode,
+ yv12_mb, search_state.best_rate_y,
+ search_state.best_rate_uv, &search_state.best_skip2,
+ winner_mode_count);
- // Initialize default mode evaluation params
- set_mode_eval_params(cpi, x, DEFAULT_EVAL);
+ // Initialize default mode evaluation params
+ set_mode_eval_params(cpi, x, DEFAULT_EVAL);
- // Only try palette mode when the best mode so far is an intra mode.
- const int try_palette =
- cpi->oxcf.tool_cfg.enable_palette &&
- av1_allow_palette(features->allow_screen_content_tools,
- mbmi->sb_type[PLANE_TYPE_Y]) &&
- !is_inter_mode(search_state.best_mbmode.mode);
- RD_STATS this_rd_cost;
- int this_skippable = 0;
- if (try_palette) {
- this_skippable = av1_search_palette_mode(
- &search_state.intra_search_state, cpi, x, bsize, intra_ref_frame_cost,
- ctx, &this_rd_cost, search_state.best_rd);
- if (this_rd_cost.rdcost < search_state.best_rd) {
- mbmi->mv[0].as_int = 0;
- rd_cost->rate = this_rd_cost.rate;
- rd_cost->dist = this_rd_cost.dist;
- rd_cost->rdcost = this_rd_cost.rdcost;
- search_state.best_rd = rd_cost->rdcost;
- search_state.best_mbmode = *mbmi;
- search_state.best_skip2 = 0;
- search_state.best_mode_skippable = this_skippable;
- memcpy(ctx->blk_skip, txfm_info->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
- av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
- }
+ // Only try palette mode when the best mode so far is an intra mode.
+ const int try_palette =
+ cpi->oxcf.tool_cfg.enable_palette &&
+ av1_allow_palette(features->allow_screen_content_tools,
+ mbmi->sb_type[PLANE_TYPE_Y]) &&
+ !is_inter_mode(search_state.best_mbmode.mode);
+ RD_STATS this_rd_cost;
+ int this_skippable = 0;
+ if (try_palette) {
+ this_skippable = av1_search_palette_mode(
+ &search_state.intra_search_state, cpi, x, bsize, intra_ref_frame_cost,
+ ctx, &this_rd_cost, search_state.best_rd);
+ if (this_rd_cost.rdcost < search_state.best_rd) {
+ mbmi->mv[0].as_int = 0;
+ rd_cost->rate = this_rd_cost.rate;
+ rd_cost->dist = this_rd_cost.dist;
+ rd_cost->rdcost = this_rd_cost.rdcost;
+ search_state.best_rd = rd_cost->rdcost;
+ search_state.best_mbmode = *mbmi;
+ search_state.best_skip2 = 0;
+ search_state.best_mode_skippable = this_skippable;
+ memcpy(ctx->blk_skip, txfm_info->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
+ av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
}
+ }
- search_state.best_mbmode.skip_mode = 0;
- if (cm->current_frame.skip_mode_info.skip_mode_flag &&
- is_comp_ref_allowed(bsize)) {
+ search_state.best_mbmode.skip_mode = 0;
+ if (cm->current_frame.skip_mode_info.skip_mode_flag &&
+ is_comp_ref_allowed(bsize)) {
#if CONFIG_NEW_REF_SIGNALING
#if CONFIG_SKIP_MODE_ENHANCEMENT
- rd_pick_motion_copy_mode(&search_state, cpi, x, bsize, yv12_mb, ctx,
- rd_cost);
+ rd_pick_motion_copy_mode(&search_state, cpi, x, bsize, yv12_mb, ctx,
+ rd_cost);
#else
rd_pick_skip_mode(rd_cost, &search_state, cpi, x, bsize, yv12_mb);
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
@@ -8303,586 +7888,589 @@
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
#endif // CONFIG_NEW_REF_SIGNALING
- }
+ }
#if CONFIG_IBC_SR_EXT
- if (search_state.best_skip2 == 0) {
- const int try_intrabc = cpi->oxcf.kf_cfg.enable_intrabc &&
- cpi->oxcf.kf_cfg.enable_intrabc_ext &&
- av1_allow_intrabc(cm) &&
- (xd->tree_type != CHROMA_PART);
- if (try_intrabc) {
- this_rd_cost.rdcost = INT64_MAX;
- mbmi->ref_frame[0] = INTRA_FRAME;
- mbmi->ref_frame[1] = NONE_FRAME;
- mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
- mbmi->mv[0].as_int = 0;
- mbmi->skip_mode = 0;
- mbmi->mode = 0;
+ if (search_state.best_skip2 == 0) {
+ const int try_intrabc = cpi->oxcf.kf_cfg.enable_intrabc &&
+ cpi->oxcf.kf_cfg.enable_intrabc_ext &&
+ av1_allow_intrabc(cm) &&
+ (xd->tree_type != CHROMA_PART);
+ if (try_intrabc) {
+ this_rd_cost.rdcost = INT64_MAX;
+ mbmi->ref_frame[0] = INTRA_FRAME;
+ mbmi->ref_frame[1] = NONE_FRAME;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
+ mbmi->mv[0].as_int = 0;
+ mbmi->skip_mode = 0;
+ mbmi->mode = 0;
- rd_pick_intrabc_mode_sb(cpi, x, ctx, &this_rd_cost, bsize, INT64_MAX);
+ rd_pick_intrabc_mode_sb(cpi, x, ctx, &this_rd_cost, bsize, INT64_MAX);
- if (this_rd_cost.rdcost < search_state.best_rd) {
- rd_cost->rate = this_rd_cost.rate;
- rd_cost->dist = this_rd_cost.dist;
- rd_cost->rdcost = this_rd_cost.rdcost;
+ if (this_rd_cost.rdcost < search_state.best_rd) {
+ rd_cost->rate = this_rd_cost.rate;
+ rd_cost->dist = this_rd_cost.dist;
+ rd_cost->rdcost = this_rd_cost.rdcost;
- search_state.best_rd = rd_cost->rdcost;
- search_state.best_mbmode = *mbmi;
- search_state.best_skip2 =
- mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
- search_state.best_mode_skippable =
- mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
- memcpy(ctx->blk_skip, txfm_info->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
- av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
- ctx->rd_stats.skip_txfm =
- mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
- }
+ search_state.best_rd = rd_cost->rdcost;
+ search_state.best_mbmode = *mbmi;
+ search_state.best_skip2 = mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
+ search_state.best_mode_skippable =
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
+ memcpy(ctx->blk_skip, txfm_info->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
+ av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
+ ctx->rd_stats.skip_txfm = mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
}
}
+ }
#endif // CONFIG_IBC_SR_EXT
- // Make sure that the ref_mv_idx is only nonzero when we're
- // using a mode which can support ref_mv_idx
- if (search_state.best_mbmode.ref_mv_idx != 0 &&
- !(have_newmv_in_each_reference(search_state.best_mbmode.mode) ||
+ // Make sure that the ref_mv_idx is only nonzero when we're
+ // using a mode which can support ref_mv_idx
+ if (search_state.best_mbmode.ref_mv_idx != 0 &&
+ !(have_newmv_in_each_reference(search_state.best_mbmode.mode) ||
#if CONFIG_JOINT_MVD
- is_joint_mvd_coding_mode(search_state.best_mbmode.mode) ||
+ is_joint_mvd_coding_mode(search_state.best_mbmode.mode) ||
#endif // CONFIG_JOINT_MVD
- have_nearmv_in_inter_mode(search_state.best_mbmode.mode))) {
- search_state.best_mbmode.ref_mv_idx = 0;
- }
+ have_nearmv_in_inter_mode(search_state.best_mbmode.mode))) {
+ search_state.best_mbmode.ref_mv_idx = 0;
+ }
- if (search_state.best_mbmode.mode == MODE_INVALID ||
- search_state.best_rd >= best_rd_so_far) {
- rd_cost->rate = INT_MAX;
- rd_cost->rdcost = INT64_MAX;
- return;
- }
+ if (search_state.best_mbmode.mode == MODE_INVALID ||
+ search_state.best_rd >= best_rd_so_far) {
+ rd_cost->rate = INT_MAX;
+ rd_cost->rdcost = INT64_MAX;
+ return;
+ }
- const InterpFilter interp_filter = features->interp_filter;
- (void)interp_filter;
- assert((interp_filter == SWITCHABLE) ||
- (interp_filter == search_state.best_mbmode.interp_fltr) ||
- !is_inter_block(&search_state.best_mbmode, xd->tree_type));
+ const InterpFilter interp_filter = features->interp_filter;
+ (void)interp_filter;
+ assert((interp_filter == SWITCHABLE) ||
+ (interp_filter == search_state.best_mbmode.interp_fltr) ||
+ !is_inter_block(&search_state.best_mbmode, xd->tree_type));
- if (!cpi->rc.is_src_frame_alt_ref && cpi->sf.inter_sf.adaptive_rd_thresh) {
- av1_update_rd_thresh_fact(cm, x->thresh_freq_fact,
- sf->inter_sf.adaptive_rd_thresh, bsize,
+ if (!cpi->rc.is_src_frame_alt_ref && cpi->sf.inter_sf.adaptive_rd_thresh) {
+ av1_update_rd_thresh_fact(cm, x->thresh_freq_fact,
+ sf->inter_sf.adaptive_rd_thresh, bsize,
#if !CONFIG_NEW_REF_SIGNALING
- search_state.best_mbmode.ref_frame,
+ search_state.best_mbmode.ref_frame,
#endif // !CONFIG_NEW_REF_SIGNALING
- search_state.best_mbmode.mode);
- }
- // macroblock modes
- *mbmi = search_state.best_mbmode;
- assert(av1_check_newmv_joint_nonzero(cm, x));
+ search_state.best_mbmode.mode);
+ }
+ // macroblock modes
+ *mbmi = search_state.best_mbmode;
+ assert(av1_check_newmv_joint_nonzero(cm, x));
#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
- assert(check_mv_precision(cm, mbmi));
- CHECK_FLEX_MV(
- check_mv_precision(cm, mbmi) == 0,
- " precision and MV mismatch in the funtion av1_rd_pick_inter_mode_sb");
+ assert(check_mv_precision(cm, mbmi));
+ CHECK_FLEX_MV(
+ check_mv_precision(cm, mbmi) == 0,
+ " precision and MV mismatch in the funtion av1_rd_pick_inter_mode_sb");
- error_check_flexmv(mbmi->pb_mv_precision < MV_PRECISION_8_PEL ||
- mbmi->pb_mv_precision >= NUM_MV_PRECISIONS,
+ error_check_flexmv(mbmi->pb_mv_precision < MV_PRECISION_8_PEL ||
+ mbmi->pb_mv_precision >= NUM_MV_PRECISIONS,
+ &cm->error,
+ " mv precision value is out of bound in the function "
+ "av1_rd_pick_inter_mode_sb");
+
+ error_check_flexmv(
+ check_mv_precision(cm, mbmi) == 0, &cm->error,
+ " incorrect mv precision in the function av1_rd_pick_inter_mode_sb");
+
+ if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
+ error_check_flexmv(mbmi->pb_mv_precision > mbmi->max_mv_precision,
&cm->error,
- " mv precision value is out of bound in the function "
+ " pb precision is higher than the maximum value at the "
+ "end of the av1_rd_pick_inter_mode_sb");
+ } else if (!is_intrabc_block(mbmi, xd->tree_type)) {
+ error_check_flexmv(mbmi->pb_mv_precision != mbmi->max_mv_precision,
+ &cm->error,
+ " pb and mb precisions are not same at the end of the "
"av1_rd_pick_inter_mode_sb");
-
- error_check_flexmv(
- check_mv_precision(cm, mbmi) == 0, &cm->error,
- " incorrect mv precision in the function av1_rd_pick_inter_mode_sb");
-
- if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
- error_check_flexmv(
- mbmi->pb_mv_precision > mbmi->max_mv_precision, &cm->error,
- " pb precision is higher than the maximum value at the "
- "end of the av1_rd_pick_inter_mode_sb");
- } else if (!is_intrabc_block(mbmi, xd->tree_type)) {
- error_check_flexmv(mbmi->pb_mv_precision != mbmi->max_mv_precision,
- &cm->error,
- " pb and mb precisions are not same at the end of the "
- "av1_rd_pick_inter_mode_sb");
- }
+ }
#endif
- txfm_info->skip_txfm |= search_state.best_skip2;
+ txfm_info->skip_txfm |= search_state.best_skip2;
- // Note: this section is needed since the mode may have been forced to
- // GLOBALMV by the all-zero mode handling of ref-mv.
- if (mbmi->mode == GLOBALMV || mbmi->mode == GLOBAL_GLOBALMV) {
- // Correct the interp filters for GLOBALMV
- if (is_nontrans_global_motion(xd, xd->mi[0])) {
- assert(mbmi->interp_fltr == av1_unswitchable_filter(interp_filter));
- }
+ // Note: this section is needed since the mode may have been forced to
+ // GLOBALMV by the all-zero mode handling of ref-mv.
+ if (mbmi->mode == GLOBALMV || mbmi->mode == GLOBAL_GLOBALMV) {
+ // Correct the interp filters for GLOBALMV
+ if (is_nontrans_global_motion(xd, xd->mi[0])) {
+ assert(mbmi->interp_fltr == av1_unswitchable_filter(interp_filter));
}
+ }
- for (i = 0; i < REFERENCE_MODES; ++i) {
- if (search_state.intra_search_state.best_pred_rd[i] == INT64_MAX) {
- search_state.best_pred_diff[i] = INT_MIN;
- } else {
- search_state.best_pred_diff[i] =
- search_state.best_rd -
- search_state.intra_search_state.best_pred_rd[i];
- }
+ for (i = 0; i < REFERENCE_MODES; ++i) {
+ if (search_state.intra_search_state.best_pred_rd[i] == INT64_MAX) {
+ search_state.best_pred_diff[i] = INT_MIN;
+ } else {
+ search_state.best_pred_diff[i] =
+ search_state.best_rd -
+ search_state.intra_search_state.best_pred_rd[i];
}
+ }
#if CONFIG_FLEX_MVRES && DEBUG_FLEX_MV
- assert(check_mv_precision(cm, mbmi));
- CHECK_FLEX_MV(
- check_mv_precision(cm, mbmi) == 0,
- " precision and MV mismatch in the funtion av1_rd_pick_inter_mode_sb");
+ assert(check_mv_precision(cm, mbmi));
+ CHECK_FLEX_MV(
+ check_mv_precision(cm, mbmi) == 0,
+ " precision and MV mismatch in the funtion av1_rd_pick_inter_mode_sb");
- error_check_flexmv(mbmi->pb_mv_precision < MV_PRECISION_8_PEL ||
- mbmi->pb_mv_precision >= NUM_MV_PRECISIONS,
+ error_check_flexmv(mbmi->pb_mv_precision < MV_PRECISION_8_PEL ||
+ mbmi->pb_mv_precision >= NUM_MV_PRECISIONS,
+ &cm->error,
+ " mv precision value is out of bound in the function "
+ "av1_rd_pick_inter_mode_sb");
+
+ error_check_flexmv(
+ check_mv_precision(cm, mbmi) == 0, &cm->error,
+ " incorrect mv precision in the function av1_rd_pick_inter_mode_sb");
+
+ if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
+ error_check_flexmv(mbmi->pb_mv_precision > mbmi->max_mv_precision,
&cm->error,
- " mv precision value is out of bound in the function "
+ " pb precision is higher than the maximum value at the "
+ "end of the av1_rd_pick_inter_mode_sb");
+ } else if (!is_intrabc_block(mbmi, xd->tree_type)) {
+ if (mbmi->pb_mv_precision != mbmi->max_mv_precision)
+ printf(
+ " mbmi->max_mv_precision = %d mbmi->pb_mv_precision= %d, "
+ "mbmi->mode = %d mbmi->ref_mv_idx = %d \n",
+ mbmi->max_mv_precision, mbmi->pb_mv_precision, mbmi->mode,
+ mbmi->ref_mv_idx);
+
+ error_check_flexmv(mbmi->pb_mv_precision != mbmi->max_mv_precision,
+ &cm->error,
+ " pb and mb precisions are not same at the end of the "
"av1_rd_pick_inter_mode_sb");
-
- error_check_flexmv(
- check_mv_precision(cm, mbmi) == 0, &cm->error,
- " incorrect mv precision in the function av1_rd_pick_inter_mode_sb");
-
- if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
- error_check_flexmv(
- mbmi->pb_mv_precision > mbmi->max_mv_precision, &cm->error,
- " pb precision is higher than the maximum value at the "
- "end of the av1_rd_pick_inter_mode_sb");
- } else if (!is_intrabc_block(mbmi, xd->tree_type)) {
- if (mbmi->pb_mv_precision != mbmi->max_mv_precision)
- printf(
- " mbmi->max_mv_precision = %d mbmi->pb_mv_precision= %d, "
- "mbmi->mode = %d mbmi->ref_mv_idx = %d \n",
- mbmi->max_mv_precision, mbmi->pb_mv_precision, mbmi->mode,
- mbmi->ref_mv_idx);
-
- error_check_flexmv(mbmi->pb_mv_precision != mbmi->max_mv_precision,
- &cm->error,
- " pb and mb precisions are not same at the end of the "
- "av1_rd_pick_inter_mode_sb");
- }
+ }
#endif
- txfm_info->skip_txfm |= search_state.best_mode_skippable;
+ txfm_info->skip_txfm |= search_state.best_mode_skippable;
- assert(search_state.best_mbmode.mode != MODE_INVALID);
+ assert(search_state.best_mbmode.mode != MODE_INVALID);
#if CONFIG_INTERNAL_STATS && !CONFIG_NEW_REF_SIGNALING
- const THR_MODES best_mode_enum = get_prediction_mode_idx(
- search_state.best_mbmode.mode, search_state.best_mbmode.ref_frame[0],
- search_state.best_mbmode.ref_frame[1]);
- store_coding_context(x, ctx, best_mode_enum, search_state.best_pred_diff,
- search_state.best_mode_skippable);
+ const THR_MODES best_mode_enum = get_prediction_mode_idx(
+ search_state.best_mbmode.mode, search_state.best_mbmode.ref_frame[0],
+ search_state.best_mbmode.ref_frame[1]);
+ store_coding_context(x, ctx, best_mode_enum, search_state.best_pred_diff,
+ search_state.best_mode_skippable);
#else
store_coding_context(x, ctx, search_state.best_pred_diff,
search_state.best_mode_skippable);
#endif // CONFIG_INTERNAL_STATS && !CONFIG_NEW_REF_SIGNALING
- if (mbmi->palette_mode_info.palette_size[1] > 0) {
- assert(try_palette);
- av1_restore_uv_color_map(cpi, x);
- }
+ if (mbmi->palette_mode_info.palette_size[1] > 0) {
+ assert(try_palette);
+ av1_restore_uv_color_map(cpi, x);
}
+}
- void av1_rd_pick_inter_mode_sb_seg_skip(
- const AV1_COMP *cpi, TileDataEnc *tile_data, MACROBLOCK *x, int mi_row,
- int mi_col, RD_STATS *rd_cost, BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
- int64_t best_rd_so_far) {
- const AV1_COMMON *const cm = &cpi->common;
- const FeatureFlags *const features = &cm->features;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- unsigned char segment_id = mbmi->segment_id;
- const int comp_pred = 0;
- int i;
- int64_t best_pred_diff[REFERENCE_MODES];
- unsigned int ref_costs_single[SINGLE_REF_FRAMES];
- unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES];
- const ModeCosts *mode_costs = &x->mode_costs;
- const int *comp_inter_cost =
- mode_costs->comp_inter_cost[av1_get_reference_mode_context(cm, xd)];
- InterpFilter best_filter = SWITCHABLE;
- int64_t this_rd = INT64_MAX;
- int rate2 = 0;
- const int64_t distortion2 = 0;
- (void)mi_row;
- (void)mi_col;
- (void)tile_data;
+void av1_rd_pick_inter_mode_sb_seg_skip(const AV1_COMP *cpi,
+ TileDataEnc *tile_data, MACROBLOCK *x,
+ int mi_row, int mi_col,
+ RD_STATS *rd_cost, BLOCK_SIZE bsize,
+ PICK_MODE_CONTEXT *ctx,
+ int64_t best_rd_so_far) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const FeatureFlags *const features = &cm->features;
+ MACROBLOCKD *const xd = &x->e_mbd;
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ unsigned char segment_id = mbmi->segment_id;
+ const int comp_pred = 0;
+ int i;
+ int64_t best_pred_diff[REFERENCE_MODES];
+ unsigned int ref_costs_single[SINGLE_REF_FRAMES];
+ unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES];
+ const ModeCosts *mode_costs = &x->mode_costs;
+ const int *comp_inter_cost =
+ mode_costs->comp_inter_cost[av1_get_reference_mode_context(cm, xd)];
+ InterpFilter best_filter = SWITCHABLE;
+ int64_t this_rd = INT64_MAX;
+ int rate2 = 0;
+ const int64_t distortion2 = 0;
+ (void)mi_row;
+ (void)mi_col;
+ (void)tile_data;
- av1_collect_neighbors_ref_counts(xd);
+ av1_collect_neighbors_ref_counts(xd);
- estimate_ref_frame_costs(cm, xd, mode_costs, segment_id, ref_costs_single,
- ref_costs_comp);
+ estimate_ref_frame_costs(cm, xd, mode_costs, segment_id, ref_costs_single,
+ ref_costs_comp);
- for (i = 0; i < REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
+ for (i = 0; i < REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
#if CONFIG_NEW_REF_SIGNALING
- for (i = 0; i < REF_FRAMES; ++i) x->pred_mv_sad[i] = INT_MAX;
+ for (i = 0; i < REF_FRAMES; ++i) x->pred_mv_sad[i] = INT_MAX;
#else
for (i = LAST_FRAME; i < REF_FRAMES; ++i) x->pred_mv_sad[i] = INT_MAX;
#endif // CONFIG_NEW_REF_SIGNALING
#if CONFIG_TIP
- x->pred_sse[TIP_FRAME_INDEX] = INT_MAX;
- x->pred_mv_sad[TIP_FRAME_INDEX] = INT_MAX;
+ x->pred_sse[TIP_FRAME_INDEX] = INT_MAX;
+ x->pred_mv_sad[TIP_FRAME_INDEX] = INT_MAX;
#endif // CONFIG_TIP
- rd_cost->rate = INT_MAX;
+ rd_cost->rate = INT_MAX;
- assert(segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP));
+ assert(segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP));
- mbmi->palette_mode_info.palette_size[0] = 0;
- mbmi->palette_mode_info.palette_size[1] = 0;
- mbmi->filter_intra_mode_info.use_filter_intra = 0;
- mbmi->mode = GLOBALMV;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->uv_mode = UV_DC_PRED;
+ mbmi->palette_mode_info.palette_size[0] = 0;
+ mbmi->palette_mode_info.palette_size[1] = 0;
+ mbmi->filter_intra_mode_info.use_filter_intra = 0;
+ mbmi->mode = GLOBALMV;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->uv_mode = UV_DC_PRED;
#if CONFIG_NEW_REF_SIGNALING
- const MV_REFERENCE_FRAME last_frame = get_closest_pastcur_ref_index(cm);
- mbmi->ref_frame[0] = last_frame;
+ const MV_REFERENCE_FRAME last_frame = get_closest_pastcur_ref_index(cm);
+ mbmi->ref_frame[0] = last_frame;
#else
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME))
mbmi->ref_frame[0] = get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME);
else
mbmi->ref_frame[0] = LAST_FRAME;
#endif // CONFIG_NEW_REF_SIGNALING
- mbmi->ref_frame[1] = NONE_FRAME;
+ mbmi->ref_frame[1] = NONE_FRAME;
#if CONFIG_TIP
- if (is_tip_ref_frame(mbmi->ref_frame[0])) {
- mbmi->mv[0].as_int = 0;
- } else {
+ if (is_tip_ref_frame(mbmi->ref_frame[0])) {
+ mbmi->mv[0].as_int = 0;
+ } else {
#endif // CONFIG_TIP
- mbmi->mv[0].as_int =
+ mbmi->mv[0].as_int =
#if CONFIG_FLEX_MVRES
- gm_get_motion_vector(&cm->global_motion[mbmi->ref_frame[0]],
- features->fr_mv_precision, bsize, mi_col, mi_row)
+ gm_get_motion_vector(&cm->global_motion[mbmi->ref_frame[0]],
+ features->fr_mv_precision, bsize, mi_col, mi_row)
#else
gm_get_motion_vector(&cm->global_motion[mbmi->ref_frame[0]],
features->allow_high_precision_mv, bsize, mi_col,
mi_row, features->cur_frame_force_integer_mv)
#endif
- .as_int;
+ .as_int;
#if CONFIG_TIP
- }
+ }
#endif // CONFIG_TIP
- mbmi->tx_size = max_txsize_lookup[bsize];
- x->txfm_search_info.skip_txfm = 1;
- mbmi->ref_mv_idx = 0;
+ mbmi->tx_size = max_txsize_lookup[bsize];
+ x->txfm_search_info.skip_txfm = 1;
+ mbmi->ref_mv_idx = 0;
#if CONFIG_DERIVED_MV
- mbmi->derived_mv_allowed = mbmi->use_derived_mv = 0;
+ mbmi->derived_mv_allowed = mbmi->use_derived_mv = 0;
#endif // CONFIG_DEIRVED_MV
- mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
#if CONFIG_FLEX_MVRES
- set_default_max_mv_precision(mbmi, xd->sbi->sb_mv_precision);
- set_mv_precision(mbmi, mbmi->max_mv_precision);
+ set_default_max_mv_precision(mbmi, xd->sbi->sb_mv_precision);
+ set_mv_precision(mbmi, mbmi->max_mv_precision);
#if ADAPTIVE_PRECISION_SETS
- set_default_precision_set(cm, mbmi, bsize);
+ set_default_precision_set(cm, mbmi, bsize);
#endif
- set_most_probable_mv_precision(cm, mbmi, bsize);
+ set_most_probable_mv_precision(cm, mbmi, bsize);
#endif
- av1_count_overlappable_neighbors(cm, xd);
- if (is_motion_variation_allowed_bsize(bsize) && !has_second_ref(mbmi)) {
- int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
- mbmi->num_proj_ref = av1_findSamples(cm, xd, pts, pts_inref);
- // Select the samples according to motion vector difference
- if (mbmi->num_proj_ref > 1)
- mbmi->num_proj_ref = av1_selectSamples(
- &mbmi->mv[0].as_mv, pts, pts_inref, mbmi->num_proj_ref, bsize);
- }
+ av1_count_overlappable_neighbors(cm, xd);
+ if (is_motion_variation_allowed_bsize(bsize) && !has_second_ref(mbmi)) {
+ int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
+ mbmi->num_proj_ref = av1_findSamples(cm, xd, pts, pts_inref);
+ // Select the samples according to motion vector difference
+ if (mbmi->num_proj_ref > 1)
+ mbmi->num_proj_ref = av1_selectSamples(&mbmi->mv[0].as_mv, pts, pts_inref,
+ mbmi->num_proj_ref, bsize);
+ }
- const InterpFilter interp_filter = features->interp_filter;
- set_default_interp_filters(mbmi,
+ const InterpFilter interp_filter = features->interp_filter;
+ set_default_interp_filters(mbmi,
#if CONFIG_OPTFLOW_REFINEMENT
- cm,
+ cm,
#endif // CONFIG_OPTFLOW_REFINEMENT
- interp_filter);
+ interp_filter);
- if (interp_filter != SWITCHABLE) {
- best_filter = interp_filter;
- } else {
- best_filter = EIGHTTAP_REGULAR;
- if (av1_is_interp_needed(cm, xd)) {
- int rs;
- int best_rs = INT_MAX;
- for (i = 0; i < SWITCHABLE_FILTERS; ++i) {
- mbmi->interp_fltr = i;
- rs = av1_get_switchable_rate(x, xd, interp_filter);
- if (rs < best_rs) {
- best_rs = rs;
- best_filter = i;
- }
+ if (interp_filter != SWITCHABLE
+#if CONFIG_FLEX_MVRES && DISABLE_OBMC_WARPED_INTER_INTRA_LOWER_PRECISION == 2
+ || skip_interpolation_filter_search_precision(cm, mbmi, bsize)
+#endif
+ ) {
+ best_filter = interp_filter;
+ } else {
+ best_filter = EIGHTTAP_REGULAR;
+ if (av1_is_interp_needed(cm, xd)) {
+ int rs;
+ int best_rs = INT_MAX;
+ for (i = 0; i < SWITCHABLE_FILTERS; ++i) {
+ mbmi->interp_fltr = i;
+ rs = av1_get_switchable_rate(x, xd, interp_filter);
+ if (rs < best_rs) {
+ best_rs = rs;
+ best_filter = i;
}
}
}
- // Set the appropriate filter
- mbmi->interp_fltr = best_filter;
- rate2 += av1_get_switchable_rate(x, xd, interp_filter);
+ }
+ // Set the appropriate filter
+ mbmi->interp_fltr = best_filter;
+ rate2 += av1_get_switchable_rate(x, xd, interp_filter);
- if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT)
- rate2 += comp_inter_cost[comp_pred];
+ if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT)
+ rate2 += comp_inter_cost[comp_pred];
- // Estimate the reference frame signaling cost and add it
- // to the rolling cost variable.
+ // Estimate the reference frame signaling cost and add it
+ // to the rolling cost variable.
#if CONFIG_NEW_REF_SIGNALING
- rate2 += ref_costs_single[last_frame];
+ rate2 += ref_costs_single[last_frame];
#else
rate2 += ref_costs_single[LAST_FRAME];
#endif // CONFIG_NEW_REF_SIGNALING
- this_rd = RDCOST(x->rdmult, rate2, distortion2);
+ this_rd = RDCOST(x->rdmult, rate2, distortion2);
- rd_cost->rate = rate2;
- rd_cost->dist = distortion2;
- rd_cost->rdcost = this_rd;
+ rd_cost->rate = rate2;
+ rd_cost->dist = distortion2;
+ rd_cost->rdcost = this_rd;
- if (this_rd >= best_rd_so_far) {
- rd_cost->rate = INT_MAX;
- rd_cost->rdcost = INT64_MAX;
- return;
- }
+ if (this_rd >= best_rd_so_far) {
+ rd_cost->rate = INT_MAX;
+ rd_cost->rdcost = INT64_MAX;
+ return;
+ }
- assert((interp_filter == SWITCHABLE) ||
- (interp_filter == mbmi->interp_fltr));
+ assert((interp_filter == SWITCHABLE) || (interp_filter == mbmi->interp_fltr));
- if (cpi->sf.inter_sf.adaptive_rd_thresh) {
+ if (cpi->sf.inter_sf.adaptive_rd_thresh) {
#if !CONFIG_NEW_REF_SIGNALING
- MV_REFERENCE_FRAME global_mv_refs[2] = { LAST_FRAME, INTRA_FRAME };
+ MV_REFERENCE_FRAME global_mv_refs[2] = { LAST_FRAME, INTRA_FRAME };
#endif // !CONFIG_NEW_REF_SIGNALING
- av1_update_rd_thresh_fact(cm, x->thresh_freq_fact,
- cpi->sf.inter_sf.adaptive_rd_thresh, bsize,
+ av1_update_rd_thresh_fact(cm, x->thresh_freq_fact,
+ cpi->sf.inter_sf.adaptive_rd_thresh, bsize,
#if !CONFIG_NEW_REF_SIGNALING
- global_mv_refs,
+ global_mv_refs,
#endif // !CONFIG_NEW_REF_SIGNALING
- GLOBALMV);
- }
+ GLOBALMV);
+ }
- av1_zero(best_pred_diff);
+ av1_zero(best_pred_diff);
#if CONFIG_INTERNAL_STATS && !CONFIG_NEW_REF_SIGNALING
- store_coding_context(x, ctx, THR_GLOBALMV, best_pred_diff, 0);
+ store_coding_context(x, ctx, THR_GLOBALMV, best_pred_diff, 0);
#else
store_coding_context(x, ctx, best_pred_diff, 0);
#endif // CONFIG_INTERNAL_STATS && !CONFIG_NEW_REF_SIGNALING
+}
+
+/*!\cond */
+struct calc_target_weighted_pred_ctxt {
+ const OBMCBuffer *obmc_buffer;
+ const uint8_t *tmp;
+ int tmp_stride;
+ int overlap;
+};
+/*!\endcond */
+
+static INLINE void calc_target_weighted_pred_above(
+ MACROBLOCKD *xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
+ int dir, MB_MODE_INFO *nb_mi, void *fun_ctxt, const int num_planes) {
+ (void)nb_mi;
+ (void)num_planes;
+ (void)rel_mi_row;
+ (void)dir;
+
+ struct calc_target_weighted_pred_ctxt *ctxt =
+ (struct calc_target_weighted_pred_ctxt *)fun_ctxt;
+
+ const int bw = xd->width << MI_SIZE_LOG2;
+ const uint8_t *const mask1d = av1_get_obmc_mask(ctxt->overlap);
+
+ int32_t *wsrc = ctxt->obmc_buffer->wsrc + (rel_mi_col * MI_SIZE);
+ int32_t *mask = ctxt->obmc_buffer->mask + (rel_mi_col * MI_SIZE);
+ const uint8_t *tmp = ctxt->tmp + rel_mi_col * MI_SIZE;
+ const int is_hbd = is_cur_buf_hbd(xd);
+
+ if (!is_hbd) {
+ for (int row = 0; row < ctxt->overlap; ++row) {
+ const uint8_t m0 = mask1d[row];
+ const uint8_t m1 = AOM_BLEND_A64_MAX_ALPHA - m0;
+ for (int col = 0; col < op_mi_size * MI_SIZE; ++col) {
+ wsrc[col] = m1 * tmp[col];
+ mask[col] = m0;
+ }
+ wsrc += bw;
+ mask += bw;
+ tmp += ctxt->tmp_stride;
+ }
+ } else {
+ const uint16_t *tmp16 = CONVERT_TO_SHORTPTR(tmp);
+
+ for (int row = 0; row < ctxt->overlap; ++row) {
+ const uint8_t m0 = mask1d[row];
+ const uint8_t m1 = AOM_BLEND_A64_MAX_ALPHA - m0;
+ for (int col = 0; col < op_mi_size * MI_SIZE; ++col) {
+ wsrc[col] = m1 * tmp16[col];
+ mask[col] = m0;
+ }
+ wsrc += bw;
+ mask += bw;
+ tmp16 += ctxt->tmp_stride;
+ }
}
+}
- /*!\cond */
- struct calc_target_weighted_pred_ctxt {
- const OBMCBuffer *obmc_buffer;
- const uint8_t *tmp;
- int tmp_stride;
- int overlap;
- };
- /*!\endcond */
+static INLINE void calc_target_weighted_pred_left(
+ MACROBLOCKD *xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
+ int dir, MB_MODE_INFO *nb_mi, void *fun_ctxt, const int num_planes) {
+ (void)nb_mi;
+ (void)num_planes;
+ (void)rel_mi_col;
+ (void)dir;
- static INLINE void calc_target_weighted_pred_above(
- MACROBLOCKD * xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
- int dir, MB_MODE_INFO *nb_mi, void *fun_ctxt, const int num_planes) {
- (void)nb_mi;
- (void)num_planes;
- (void)rel_mi_row;
- (void)dir;
+ struct calc_target_weighted_pred_ctxt *ctxt =
+ (struct calc_target_weighted_pred_ctxt *)fun_ctxt;
- struct calc_target_weighted_pred_ctxt *ctxt =
- (struct calc_target_weighted_pred_ctxt *)fun_ctxt;
+ const int bw = xd->width << MI_SIZE_LOG2;
+ const uint8_t *const mask1d = av1_get_obmc_mask(ctxt->overlap);
- const int bw = xd->width << MI_SIZE_LOG2;
- const uint8_t *const mask1d = av1_get_obmc_mask(ctxt->overlap);
+ int32_t *wsrc = ctxt->obmc_buffer->wsrc + (rel_mi_row * MI_SIZE * bw);
+ int32_t *mask = ctxt->obmc_buffer->mask + (rel_mi_row * MI_SIZE * bw);
+ const uint8_t *tmp = ctxt->tmp + (rel_mi_row * MI_SIZE * ctxt->tmp_stride);
+ const int is_hbd = is_cur_buf_hbd(xd);
- int32_t *wsrc = ctxt->obmc_buffer->wsrc + (rel_mi_col * MI_SIZE);
- int32_t *mask = ctxt->obmc_buffer->mask + (rel_mi_col * MI_SIZE);
- const uint8_t *tmp = ctxt->tmp + rel_mi_col * MI_SIZE;
- const int is_hbd = is_cur_buf_hbd(xd);
-
- if (!is_hbd) {
- for (int row = 0; row < ctxt->overlap; ++row) {
- const uint8_t m0 = mask1d[row];
+ if (!is_hbd) {
+ for (int row = 0; row < op_mi_size * MI_SIZE; ++row) {
+ for (int col = 0; col < ctxt->overlap; ++col) {
+ const uint8_t m0 = mask1d[col];
const uint8_t m1 = AOM_BLEND_A64_MAX_ALPHA - m0;
- for (int col = 0; col < op_mi_size * MI_SIZE; ++col) {
- wsrc[col] = m1 * tmp[col];
- mask[col] = m0;
- }
- wsrc += bw;
- mask += bw;
- tmp += ctxt->tmp_stride;
+ wsrc[col] = (wsrc[col] >> AOM_BLEND_A64_ROUND_BITS) * m0 +
+ (tmp[col] << AOM_BLEND_A64_ROUND_BITS) * m1;
+ mask[col] = (mask[col] >> AOM_BLEND_A64_ROUND_BITS) * m0;
}
- } else {
- const uint16_t *tmp16 = CONVERT_TO_SHORTPTR(tmp);
+ wsrc += bw;
+ mask += bw;
+ tmp += ctxt->tmp_stride;
+ }
+ } else {
+ const uint16_t *tmp16 = CONVERT_TO_SHORTPTR(tmp);
- for (int row = 0; row < ctxt->overlap; ++row) {
- const uint8_t m0 = mask1d[row];
+ for (int row = 0; row < op_mi_size * MI_SIZE; ++row) {
+ for (int col = 0; col < ctxt->overlap; ++col) {
+ const uint8_t m0 = mask1d[col];
const uint8_t m1 = AOM_BLEND_A64_MAX_ALPHA - m0;
- for (int col = 0; col < op_mi_size * MI_SIZE; ++col) {
- wsrc[col] = m1 * tmp16[col];
- mask[col] = m0;
- }
- wsrc += bw;
- mask += bw;
- tmp16 += ctxt->tmp_stride;
+ wsrc[col] = (wsrc[col] >> AOM_BLEND_A64_ROUND_BITS) * m0 +
+ (tmp16[col] << AOM_BLEND_A64_ROUND_BITS) * m1;
+ mask[col] = (mask[col] >> AOM_BLEND_A64_ROUND_BITS) * m0;
}
+ wsrc += bw;
+ mask += bw;
+ tmp16 += ctxt->tmp_stride;
}
}
+}
- static INLINE void calc_target_weighted_pred_left(
- MACROBLOCKD * xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
- int dir, MB_MODE_INFO *nb_mi, void *fun_ctxt, const int num_planes) {
- (void)nb_mi;
- (void)num_planes;
- (void)rel_mi_col;
- (void)dir;
+// This function has a structure similar to av1_build_obmc_inter_prediction
+//
+// The OBMC predictor is computed as:
+//
+// PObmc(x,y) =
+// AOM_BLEND_A64(Mh(x),
+// AOM_BLEND_A64(Mv(y), P(x,y), PAbove(x,y)),
+// PLeft(x, y))
+//
+// Scaling up by AOM_BLEND_A64_MAX_ALPHA ** 2 and omitting the intermediate
+// rounding, this can be written as:
+//
+// AOM_BLEND_A64_MAX_ALPHA * AOM_BLEND_A64_MAX_ALPHA * Pobmc(x,y) =
+// Mh(x) * Mv(y) * P(x,y) +
+// Mh(x) * Cv(y) * Pabove(x,y) +
+// AOM_BLEND_A64_MAX_ALPHA * Ch(x) * PLeft(x, y)
+//
+// Where :
+//
+// Cv(y) = AOM_BLEND_A64_MAX_ALPHA - Mv(y)
+// Ch(y) = AOM_BLEND_A64_MAX_ALPHA - Mh(y)
+//
+// This function computes 'wsrc' and 'mask' as:
+//
+// wsrc(x, y) =
+// AOM_BLEND_A64_MAX_ALPHA * AOM_BLEND_A64_MAX_ALPHA * src(x, y) -
+// Mh(x) * Cv(y) * Pabove(x,y) +
+// AOM_BLEND_A64_MAX_ALPHA * Ch(x) * PLeft(x, y)
+//
+// mask(x, y) = Mh(x) * Mv(y)
+//
+// These can then be used to efficiently approximate the error for any
+// predictor P in the context of the provided neighbouring predictors by
+// computing:
+//
+// error(x, y) =
+// wsrc(x, y) - mask(x, y) * P(x, y) / (AOM_BLEND_A64_MAX_ALPHA ** 2)
+//
+static AOM_INLINE void calc_target_weighted_pred(
+ const AV1_COMMON *cm, const MACROBLOCK *x, const MACROBLOCKD *xd,
+ const uint8_t *above, int above_stride, const uint8_t *left,
+ int left_stride) {
+ const BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y];
+ const int bw = xd->width << MI_SIZE_LOG2;
+ const int bh = xd->height << MI_SIZE_LOG2;
+ const OBMCBuffer *obmc_buffer = &x->obmc_buffer;
+ int32_t *mask_buf = obmc_buffer->mask;
+ int32_t *wsrc_buf = obmc_buffer->wsrc;
- struct calc_target_weighted_pred_ctxt *ctxt =
- (struct calc_target_weighted_pred_ctxt *)fun_ctxt;
+ const int is_hbd = is_cur_buf_hbd(xd);
+ const int src_scale = AOM_BLEND_A64_MAX_ALPHA * AOM_BLEND_A64_MAX_ALPHA;
- const int bw = xd->width << MI_SIZE_LOG2;
- const uint8_t *const mask1d = av1_get_obmc_mask(ctxt->overlap);
+ // plane 0 should not be sub-sampled
+ assert(xd->plane[0].subsampling_x == 0);
+ assert(xd->plane[0].subsampling_y == 0);
- int32_t *wsrc = ctxt->obmc_buffer->wsrc + (rel_mi_row * MI_SIZE * bw);
- int32_t *mask = ctxt->obmc_buffer->mask + (rel_mi_row * MI_SIZE * bw);
- const uint8_t *tmp = ctxt->tmp + (rel_mi_row * MI_SIZE * ctxt->tmp_stride);
- const int is_hbd = is_cur_buf_hbd(xd);
+ av1_zero_array(wsrc_buf, bw * bh);
+ for (int i = 0; i < bw * bh; ++i) mask_buf[i] = AOM_BLEND_A64_MAX_ALPHA;
- if (!is_hbd) {
- for (int row = 0; row < op_mi_size * MI_SIZE; ++row) {
- for (int col = 0; col < ctxt->overlap; ++col) {
- const uint8_t m0 = mask1d[col];
- const uint8_t m1 = AOM_BLEND_A64_MAX_ALPHA - m0;
- wsrc[col] = (wsrc[col] >> AOM_BLEND_A64_ROUND_BITS) * m0 +
- (tmp[col] << AOM_BLEND_A64_ROUND_BITS) * m1;
- mask[col] = (mask[col] >> AOM_BLEND_A64_ROUND_BITS) * m0;
- }
- wsrc += bw;
- mask += bw;
- tmp += ctxt->tmp_stride;
- }
- } else {
- const uint16_t *tmp16 = CONVERT_TO_SHORTPTR(tmp);
-
- for (int row = 0; row < op_mi_size * MI_SIZE; ++row) {
- for (int col = 0; col < ctxt->overlap; ++col) {
- const uint8_t m0 = mask1d[col];
- const uint8_t m1 = AOM_BLEND_A64_MAX_ALPHA - m0;
- wsrc[col] = (wsrc[col] >> AOM_BLEND_A64_ROUND_BITS) * m0 +
- (tmp16[col] << AOM_BLEND_A64_ROUND_BITS) * m1;
- mask[col] = (mask[col] >> AOM_BLEND_A64_ROUND_BITS) * m0;
- }
- wsrc += bw;
- mask += bw;
- tmp16 += ctxt->tmp_stride;
- }
- }
+ // handle above row
+ if (xd->up_available) {
+ const int overlap =
+ AOMMIN(block_size_high[bsize], block_size_high[BLOCK_64X64]) >> 1;
+ struct calc_target_weighted_pred_ctxt ctxt = { obmc_buffer, above,
+ above_stride, overlap };
+ foreach_overlappable_nb_above(cm, (MACROBLOCKD *)xd,
+ max_neighbor_obmc[mi_size_wide_log2[bsize]],
+ calc_target_weighted_pred_above, &ctxt);
}
- // This function has a structure similar to av1_build_obmc_inter_prediction
- //
- // The OBMC predictor is computed as:
- //
- // PObmc(x,y) =
- // AOM_BLEND_A64(Mh(x),
- // AOM_BLEND_A64(Mv(y), P(x,y), PAbove(x,y)),
- // PLeft(x, y))
- //
- // Scaling up by AOM_BLEND_A64_MAX_ALPHA ** 2 and omitting the intermediate
- // rounding, this can be written as:
- //
- // AOM_BLEND_A64_MAX_ALPHA * AOM_BLEND_A64_MAX_ALPHA * Pobmc(x,y) =
- // Mh(x) * Mv(y) * P(x,y) +
- // Mh(x) * Cv(y) * Pabove(x,y) +
- // AOM_BLEND_A64_MAX_ALPHA * Ch(x) * PLeft(x, y)
- //
- // Where :
- //
- // Cv(y) = AOM_BLEND_A64_MAX_ALPHA - Mv(y)
- // Ch(y) = AOM_BLEND_A64_MAX_ALPHA - Mh(y)
- //
- // This function computes 'wsrc' and 'mask' as:
- //
- // wsrc(x, y) =
- // AOM_BLEND_A64_MAX_ALPHA * AOM_BLEND_A64_MAX_ALPHA * src(x, y) -
- // Mh(x) * Cv(y) * Pabove(x,y) +
- // AOM_BLEND_A64_MAX_ALPHA * Ch(x) * PLeft(x, y)
- //
- // mask(x, y) = Mh(x) * Mv(y)
- //
- // These can then be used to efficiently approximate the error for any
- // predictor P in the context of the provided neighbouring predictors by
- // computing:
- //
- // error(x, y) =
- // wsrc(x, y) - mask(x, y) * P(x, y) / (AOM_BLEND_A64_MAX_ALPHA ** 2)
- //
- static AOM_INLINE void calc_target_weighted_pred(
- const AV1_COMMON *cm, const MACROBLOCK *x, const MACROBLOCKD *xd,
- const uint8_t *above, int above_stride, const uint8_t *left,
- int left_stride) {
- const BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y];
- const int bw = xd->width << MI_SIZE_LOG2;
- const int bh = xd->height << MI_SIZE_LOG2;
- const OBMCBuffer *obmc_buffer = &x->obmc_buffer;
- int32_t *mask_buf = obmc_buffer->mask;
- int32_t *wsrc_buf = obmc_buffer->wsrc;
+ for (int i = 0; i < bw * bh; ++i) {
+ wsrc_buf[i] *= AOM_BLEND_A64_MAX_ALPHA;
+ mask_buf[i] *= AOM_BLEND_A64_MAX_ALPHA;
+ }
- const int is_hbd = is_cur_buf_hbd(xd);
- const int src_scale = AOM_BLEND_A64_MAX_ALPHA * AOM_BLEND_A64_MAX_ALPHA;
+ // handle left column
+ if (xd->left_available) {
+ const int overlap =
+ AOMMIN(block_size_wide[bsize], block_size_wide[BLOCK_64X64]) >> 1;
+ struct calc_target_weighted_pred_ctxt ctxt = { obmc_buffer, left,
+ left_stride, overlap };
+ foreach_overlappable_nb_left(cm, (MACROBLOCKD *)xd,
+ max_neighbor_obmc[mi_size_high_log2[bsize]],
+ calc_target_weighted_pred_left, &ctxt);
+ }
- // plane 0 should not be sub-sampled
- assert(xd->plane[0].subsampling_x == 0);
- assert(xd->plane[0].subsampling_y == 0);
+ if (!is_hbd) {
+ const uint8_t *src = x->plane[0].src.buf;
- av1_zero_array(wsrc_buf, bw * bh);
- for (int i = 0; i < bw * bh; ++i) mask_buf[i] = AOM_BLEND_A64_MAX_ALPHA;
-
- // handle above row
- if (xd->up_available) {
- const int overlap =
- AOMMIN(block_size_high[bsize], block_size_high[BLOCK_64X64]) >> 1;
- struct calc_target_weighted_pred_ctxt ctxt = { obmc_buffer, above,
- above_stride, overlap };
- foreach_overlappable_nb_above(cm, (MACROBLOCKD *)xd,
- max_neighbor_obmc[mi_size_wide_log2[bsize]],
- calc_target_weighted_pred_above, &ctxt);
- }
-
- for (int i = 0; i < bw * bh; ++i) {
- wsrc_buf[i] *= AOM_BLEND_A64_MAX_ALPHA;
- mask_buf[i] *= AOM_BLEND_A64_MAX_ALPHA;
- }
-
- // handle left column
- if (xd->left_available) {
- const int overlap =
- AOMMIN(block_size_wide[bsize], block_size_wide[BLOCK_64X64]) >> 1;
- struct calc_target_weighted_pred_ctxt ctxt = { obmc_buffer, left,
- left_stride, overlap };
- foreach_overlappable_nb_left(cm, (MACROBLOCKD *)xd,
- max_neighbor_obmc[mi_size_high_log2[bsize]],
- calc_target_weighted_pred_left, &ctxt);
- }
-
- if (!is_hbd) {
- const uint8_t *src = x->plane[0].src.buf;
-
- for (int row = 0; row < bh; ++row) {
- for (int col = 0; col < bw; ++col) {
- wsrc_buf[col] = src[col] * src_scale - wsrc_buf[col];
- }
- wsrc_buf += bw;
- src += x->plane[0].src.stride;
+ for (int row = 0; row < bh; ++row) {
+ for (int col = 0; col < bw; ++col) {
+ wsrc_buf[col] = src[col] * src_scale - wsrc_buf[col];
}
- } else {
- const uint16_t *src = CONVERT_TO_SHORTPTR(x->plane[0].src.buf);
+ wsrc_buf += bw;
+ src += x->plane[0].src.stride;
+ }
+ } else {
+ const uint16_t *src = CONVERT_TO_SHORTPTR(x->plane[0].src.buf);
- for (int row = 0; row < bh; ++row) {
- for (int col = 0; col < bw; ++col) {
- wsrc_buf[col] = src[col] * src_scale - wsrc_buf[col];
- }
- wsrc_buf += bw;
- src += x->plane[0].src.stride;
+ for (int row = 0; row < bh; ++row) {
+ for (int col = 0; col < bw; ++col) {
+ wsrc_buf[col] = src[col] * src_scale - wsrc_buf[col];
}
+ wsrc_buf += bw;
+ src += x->plane[0].src.stride;
}
}
+}
/* Use standard 3x3 Sobel matrix. Macro so it can be used for either high or
low bit-depth arrays. */
@@ -8901,98 +8489,98 @@
2 * (src)[(i) + (stride) * ((j) + 1)] - /* NOLINT */ \
(src)[((i) + 1) + (stride) * ((j) + 1)]) /* NOLINT */
- sobel_xy av1_sobel(const uint8_t *input, int stride, int i, int j,
- bool high_bd) {
- int16_t s_x;
- int16_t s_y;
- if (high_bd) {
- const uint16_t *src = CONVERT_TO_SHORTPTR(input);
- s_x = SOBEL_X(src, stride, i, j);
- s_y = SOBEL_Y(src, stride, i, j);
- } else {
- s_x = SOBEL_X(input, stride, i, j);
- s_y = SOBEL_Y(input, stride, i, j);
- }
- sobel_xy r = { .x = s_x, .y = s_y };
- return r;
+sobel_xy av1_sobel(const uint8_t *input, int stride, int i, int j,
+ bool high_bd) {
+ int16_t s_x;
+ int16_t s_y;
+ if (high_bd) {
+ const uint16_t *src = CONVERT_TO_SHORTPTR(input);
+ s_x = SOBEL_X(src, stride, i, j);
+ s_y = SOBEL_Y(src, stride, i, j);
+ } else {
+ s_x = SOBEL_X(input, stride, i, j);
+ s_y = SOBEL_Y(input, stride, i, j);
}
+ sobel_xy r = { .x = s_x, .y = s_y };
+ return r;
+}
- // 8-tap Gaussian convolution filter with sigma = 1.3, sums to 128,
- // all co-efficients must be even.
- DECLARE_ALIGNED(16, static const int16_t,
- gauss_filter[8]) = { 2, 12, 30, 40, 30, 12, 2, 0 };
+// 8-tap Gaussian convolution filter with sigma = 1.3, sums to 128,
+// all co-efficients must be even.
+DECLARE_ALIGNED(16, static const int16_t, gauss_filter[8]) = { 2, 12, 30, 40,
+ 30, 12, 2, 0 };
- void av1_gaussian_blur(const uint8_t *src, int src_stride, int w, int h,
- uint8_t *dst, bool high_bd, int bd) {
- ConvolveParams conv_params = get_conv_params(0, 0, bd);
- InterpFilterParams filter = { .filter_ptr = gauss_filter,
- .taps = 8,
- .interp_filter = EIGHTTAP_REGULAR };
- // Requirements from the vector-optimized implementations.
- assert(h % 4 == 0);
- assert(w % 8 == 0);
- // Because we use an eight tap filter, the stride should be at least 7 + w.
- assert(src_stride >= w + 7);
- if (high_bd) {
- av1_highbd_convolve_2d_sr(CONVERT_TO_SHORTPTR(src), src_stride,
- CONVERT_TO_SHORTPTR(dst), w, w, h, &filter,
- &filter, 0, 0, &conv_params, bd);
- } else {
- av1_convolve_2d_sr(src, src_stride, dst, w, w, h, &filter, &filter, 0, 0,
- &conv_params);
+void av1_gaussian_blur(const uint8_t *src, int src_stride, int w, int h,
+ uint8_t *dst, bool high_bd, int bd) {
+ ConvolveParams conv_params = get_conv_params(0, 0, bd);
+ InterpFilterParams filter = { .filter_ptr = gauss_filter,
+ .taps = 8,
+ .interp_filter = EIGHTTAP_REGULAR };
+ // Requirements from the vector-optimized implementations.
+ assert(h % 4 == 0);
+ assert(w % 8 == 0);
+ // Because we use an eight tap filter, the stride should be at least 7 + w.
+ assert(src_stride >= w + 7);
+ if (high_bd) {
+ av1_highbd_convolve_2d_sr(CONVERT_TO_SHORTPTR(src), src_stride,
+ CONVERT_TO_SHORTPTR(dst), w, w, h, &filter,
+ &filter, 0, 0, &conv_params, bd);
+ } else {
+ av1_convolve_2d_sr(src, src_stride, dst, w, w, h, &filter, &filter, 0, 0,
+ &conv_params);
+ }
+}
+
+static EdgeInfo edge_probability(const uint8_t *input, int w, int h,
+ bool high_bd, int bd) {
+ // The probability of an edge in the whole image is the same as the highest
+ // probability of an edge for any individual pixel. Use Sobel as the metric
+ // for finding an edge.
+ uint16_t highest = 0;
+ uint16_t highest_x = 0;
+ uint16_t highest_y = 0;
+ // Ignore the 1 pixel border around the image for the computation.
+ for (int j = 1; j < h - 1; ++j) {
+ for (int i = 1; i < w - 1; ++i) {
+ sobel_xy g = av1_sobel(input, w, i, j, high_bd);
+ // Scale down to 8-bit to get same output regardless of bit depth.
+ int16_t g_x = g.x >> (bd - 8);
+ int16_t g_y = g.y >> (bd - 8);
+ uint16_t magnitude = (uint16_t)sqrt(g_x * g_x + g_y * g_y);
+ highest = AOMMAX(highest, magnitude);
+ highest_x = AOMMAX(highest_x, g_x);
+ highest_y = AOMMAX(highest_y, g_y);
}
}
+ EdgeInfo ei = { .magnitude = highest, .x = highest_x, .y = highest_y };
+ return ei;
+}
- static EdgeInfo edge_probability(const uint8_t *input, int w, int h,
- bool high_bd, int bd) {
- // The probability of an edge in the whole image is the same as the highest
- // probability of an edge for any individual pixel. Use Sobel as the metric
- // for finding an edge.
- uint16_t highest = 0;
- uint16_t highest_x = 0;
- uint16_t highest_y = 0;
- // Ignore the 1 pixel border around the image for the computation.
- for (int j = 1; j < h - 1; ++j) {
- for (int i = 1; i < w - 1; ++i) {
- sobel_xy g = av1_sobel(input, w, i, j, high_bd);
- // Scale down to 8-bit to get same output regardless of bit depth.
- int16_t g_x = g.x >> (bd - 8);
- int16_t g_y = g.y >> (bd - 8);
- uint16_t magnitude = (uint16_t)sqrt(g_x * g_x + g_y * g_y);
- highest = AOMMAX(highest, magnitude);
- highest_x = AOMMAX(highest_x, g_x);
- highest_y = AOMMAX(highest_y, g_y);
- }
- }
- EdgeInfo ei = { .magnitude = highest, .x = highest_x, .y = highest_y };
- return ei;
+/* Uses most of the Canny edge detection algorithm to find if there are any
+ * edges in the image.
+ */
+EdgeInfo av1_edge_exists(const uint8_t *src, int src_stride, int w, int h,
+ bool high_bd, int bd) {
+ if (w < 3 || h < 3) {
+ EdgeInfo n = { .magnitude = 0, .x = 0, .y = 0 };
+ return n;
}
-
- /* Uses most of the Canny edge detection algorithm to find if there are any
- * edges in the image.
- */
- EdgeInfo av1_edge_exists(const uint8_t *src, int src_stride, int w, int h,
- bool high_bd, int bd) {
- if (w < 3 || h < 3) {
- EdgeInfo n = { .magnitude = 0, .x = 0, .y = 0 };
- return n;
- }
- uint8_t *blurred;
- if (high_bd) {
- blurred = CONVERT_TO_BYTEPTR(aom_memalign(32, sizeof(uint16_t) * w * h));
- } else {
- blurred = (uint8_t *)aom_memalign(32, sizeof(uint8_t) * w * h);
- }
- av1_gaussian_blur(src, src_stride, w, h, blurred, high_bd, bd);
- // Skip the non-maximum suppression step in Canny edge detection. We just
- // want a probability of an edge existing in the buffer, which is determined
- // by the strongest edge in it -- we don't need to eliminate the weaker
- // edges. Use Sobel for the edge detection.
- EdgeInfo prob = edge_probability(blurred, w, h, high_bd, bd);
- if (high_bd) {
- aom_free(CONVERT_TO_SHORTPTR(blurred));
- } else {
- aom_free(blurred);
- }
- return prob;
+ uint8_t *blurred;
+ if (high_bd) {
+ blurred = CONVERT_TO_BYTEPTR(aom_memalign(32, sizeof(uint16_t) * w * h));
+ } else {
+ blurred = (uint8_t *)aom_memalign(32, sizeof(uint8_t) * w * h);
}
+ av1_gaussian_blur(src, src_stride, w, h, blurred, high_bd, bd);
+ // Skip the non-maximum suppression step in Canny edge detection. We just
+ // want a probability of an edge existing in the buffer, which is determined
+ // by the strongest edge in it -- we don't need to eliminate the weaker
+ // edges. Use Sobel for the edge detection.
+ EdgeInfo prob = edge_probability(blurred, w, h, high_bd, bd);
+ if (high_bd) {
+ aom_free(CONVERT_TO_SHORTPTR(blurred));
+ } else {
+ aom_free(blurred);
+ }
+ return prob;
+}
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index 7dd781e..9f87bd2 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -147,6 +147,17 @@
const int is_1080p_or_larger = AOMMIN(cm->width, cm->height) >= 1080;
const int is_4k_or_larger = AOMMIN(cm->width, cm->height) >= 2160;
+#if CONFIG_FLEX_MVRES && FAST_FLEX_MV_ENCODER
+ if (is_1080p_or_larger) {
+ sf->hl_sf.high_precision_mv_usage = QTR_ONLY;
+ }
+
+ if (!is_1080p_or_larger) {
+ sf->flexmv_sf.do_not_search_8_pel_precision = 1;
+ }
+ if (!is_480p_or_larger) sf->flexmv_sf.do_not_search_4_pel_precision = 1;
+#endif
+
if (is_480p_or_larger) {
sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128;
if (is_720p_or_larger)
@@ -305,6 +316,15 @@
sf->hl_sf.high_precision_mv_usage = LAST_MV_DATA;
}
+#if CONFIG_FLEX_MVRES && FAST_FLEX_MV_ENCODER
+ sf->flexmv_sf.terminate_early_4_pel_precision = 1;
+ sf->flexmv_sf.low_prec_obmc_full_pixel_search_level = 1;
+ sf->flexmv_sf.skip_similar_ref_mv = 1;
+ sf->flexmv_sf.skip_repeated_newmv_low_prec = 1;
+ sf->flexmv_sf.fast_mv_refinement = 1;
+ sf->flexmv_sf.fast_motion_search_low_precision = 1;
+#endif
+
// Speed 0 for all speed features that give neutral coding performance change.
sf->gm_sf.gm_disable_recode = 1;
#if CONFIG_NEW_REF_SIGNALING
@@ -723,6 +743,20 @@
mv_sf->use_downsampled_sad = 0;
}
+#if CONFIG_FLEX_MVRES
+static AOM_INLINE void init_flexmv_sf(
+ FLEXMV_PRECISION_SPEED_FEATURES *flexmv_sf) {
+ flexmv_sf->do_not_search_4_pel_precision = 0;
+ flexmv_sf->do_not_search_8_pel_precision = 0;
+ flexmv_sf->terminate_early_4_pel_precision = 0;
+ flexmv_sf->low_prec_obmc_full_pixel_search_level = 0;
+ flexmv_sf->skip_similar_ref_mv = 0;
+ flexmv_sf->skip_repeated_newmv_low_prec = 0;
+ flexmv_sf->fast_mv_refinement = 0;
+ flexmv_sf->fast_motion_search_low_precision = 0;
+}
+#endif
+
static AOM_INLINE void init_inter_sf(INTER_MODE_SPEED_FEATURES *inter_sf) {
inter_sf->comp_inter_joint_search_thresh = BLOCK_4X4;
inter_sf->adaptive_rd_thresh = 0;
@@ -937,6 +971,10 @@
init_winner_mode_sf(&sf->winner_mode_sf);
init_lpf_sf(&sf->lpf_sf);
+#if CONFIG_FLEX_MVRES
+ init_flexmv_sf(&sf->flexmv_sf);
+#endif
+
if (oxcf->mode == GOOD)
set_good_speed_features_framesize_independent(cpi, sf, speed);
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index 9e86e80..e364218 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -933,6 +933,34 @@
int disable_lr_filter;
} LOOP_FILTER_SPEED_FEATURES;
+#if CONFIG_FLEX_MVRES
+typedef struct FLEXMV_PRECISION_SPEED_FEATURES {
+ // Do not search 8-pel precision
+ int do_not_search_8_pel_precision;
+
+ // Do not search 4-pel precision
+ int do_not_search_4_pel_precision;
+
+ // enable early termination than 4-pel precision
+ int terminate_early_4_pel_precision;
+
+ // fast_obmc_search for low precisions
+ int low_prec_obmc_full_pixel_search_level;
+
+ // fast_obmc_search for low precisions
+ int skip_similar_ref_mv;
+
+ // Skip RDO of the repeated newMV for lower precisions.
+ int skip_repeated_newmv_low_prec;
+
+ // Fast refinement of MV for low precision. 1 means fast refinement is enabled
+ int fast_mv_refinement;
+
+ // fast motion search
+ int fast_motion_search_low_precision;
+} FLEXMV_PRECISION_SPEED_FEATURES;
+#endif
+
/*!\endcond */
/*!
@@ -998,6 +1026,13 @@
* In-loop filter speed features:
*/
LOOP_FILTER_SPEED_FEATURES lpf_sf;
+#if CONFIG_FLEX_MVRES
+ /*!
+ * flexible MV precisions speed features:
+ */
+ FLEXMV_PRECISION_SPEED_FEATURES flexmv_sf;
+#endif
+
} SPEED_FEATURES;
/*!\cond */
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c
index 83d7f67..275884d 100644
--- a/av1/encoder/temporal_filter.c
+++ b/av1/encoder/temporal_filter.c
@@ -98,6 +98,9 @@
// Save input state.
#if CONFIG_FLEX_MVRES
const AV1_COMMON *cm = &cpi->common;
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
+#endif
#endif
MACROBLOCK *const mb = &cpi->td.mb;
MACROBLOCKD *const mbd = &mb->e_mbd;
@@ -150,6 +153,9 @@
&baseline_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
#endif
search_site_cfg,
/*fine_search_interval=*/0);
@@ -219,6 +225,9 @@
subblock_size, &baseline_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
#endif
search_site_cfg,
/*fine_search_interval=*/0);
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index 6efa5db..ad53c34 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -166,12 +166,18 @@
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = cm->features.fr_mv_precision;
full_pel_lower_mv_precision(&start_mv, pb_mv_precision);
+#if CONFIG_BVCOST_UPDATE
+ const int is_ibc_cost = 0;
+#endif
#endif
FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, ¢er_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
+#if CONFIG_BVCOST_UPDATE
+ is_ibc_cost,
+#endif
#endif
search_site_cfg,
/*fine_search_interval=*/0);
