Delta-code against scaled reference model
diff --git a/aom_dsp/bitwriter_buffer.c b/aom_dsp/bitwriter_buffer.c
index 7e41949..ac0710f 100644
--- a/aom_dsp/bitwriter_buffer.c
+++ b/aom_dsp/bitwriter_buffer.c
@@ -92,6 +92,7 @@
void aom_wb_write_primitive_quniform(struct aom_write_bit_buffer *wb,
uint16_t n, uint16_t v) {
if (n <= 1) return;
+ assert(v < n);
const int l = get_msb(n) + 1;
const int m = (1 << l) - n;
if (v < m) {
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index eee6f58..a1dac85 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -260,6 +260,12 @@
// Frame's level within the hierarchical structure
unsigned int pyramid_level;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // How many ref frames did this frame use?
+ // This is set to 0 for intra frames
+ int num_ref_frames;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
MV_REF *mvs;
uint8_t *seg_map;
struct segmentation seg;
@@ -1567,6 +1573,18 @@
*/
DeltaQInfo delta_q_info;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ /*!
+ * Base model used for delta-coding global motion parameters
+ */
+ WarpedMotionParams base_global_motion_model;
+
+ /*!
+ * Temporal length of `base_global_motion_model`
+ */
+ int base_global_motion_distance;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
/*!
* Global motion parameters for each reference frame.
*/
diff --git a/av1/common/warped_motion.h b/av1/common/warped_motion.h
index d7f2bca..e10a279 100644
--- a/av1/common/warped_motion.h
+++ b/av1/common/warped_motion.h
@@ -341,4 +341,54 @@
return motion_mode == WARPED_CAUSAL;
#endif // CONFIG_INTERINTRA_WARP
}
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+static INLINE void av1_scale_warp_model(const WarpedMotionParams *in_params,
+ int in_distance,
+ WarpedMotionParams *out_params,
+ int out_distance) {
+ static int param_shift[MAX_PARAMDIM - 1] = {
+ GM_TRANS_PREC_DIFF, GM_TRANS_PREC_DIFF, GM_ALPHA_PREC_DIFF,
+ GM_ALPHA_PREC_DIFF, GM_ALPHA_PREC_DIFF, GM_ALPHA_PREC_DIFF,
+ GM_ROW3HOMO_PREC_DIFF, GM_ROW3HOMO_PREC_DIFF
+ };
+
+ static int param_min[MAX_PARAMDIM - 1] = { GM_TRANS_MIN, GM_TRANS_MIN,
+ GM_ALPHA_MIN, GM_ALPHA_MIN,
+ GM_ALPHA_MIN, GM_ALPHA_MIN,
+ GM_ROW3HOMO_MIN, GM_ROW3HOMO_MIN };
+
+ static int param_max[MAX_PARAMDIM - 1] = { GM_TRANS_MAX, GM_TRANS_MAX,
+ GM_ALPHA_MAX, GM_ALPHA_MAX,
+ GM_ALPHA_MAX, GM_ALPHA_MAX,
+ GM_ROW3HOMO_MAX, GM_ROW3HOMO_MAX };
+
+ assert(in_distance != 0);
+ assert(out_distance != 0);
+
+ // Flip signs so that in_distance is positive.
+ // We do this because
+ // scaled_value = (... + divisor/2) / divisor
+ // is the simplest way to implement division with round-to-nearest in C,
+ // but it only works correctly if the divisor is positive
+ if (in_distance < 0) {
+ in_distance = -in_distance;
+ out_distance = -out_distance;
+ }
+
+ out_params->wmtype = in_params->wmtype;
+ for (int param = 0; param < MAX_PARAMDIM - 1; param++) {
+ int center = default_warp_params.wmmat[param];
+
+ int input = in_params->wmmat[param] - center;
+ int divisor = in_distance << param_shift[param];
+ int output = (int)(((int64_t)input * out_distance + divisor / 2) / divisor);
+ output = clamp(output, param_min[param], param_max[param])
+ << param_shift[param];
+
+ out_params->wmmat[param] = center + output;
+ }
+}
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
#endif // AOM_AV1_COMMON_WARPED_MOTION_H_
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 8651d3c..6836712 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -6203,8 +6203,10 @@
static AOM_INLINE void read_global_motion(AV1_COMMON *cm,
struct aom_read_bit_buffer *rb) {
#if CONFIG_IMPROVED_GLOBAL_MOTION
+ const SequenceHeader *const seq_params = &cm->seq_params;
+ int num_total_refs = cm->ref_frames_info.num_total_refs;
bool use_global_motion = false;
- if (cm->seq_params.enable_global_motion) {
+ if (seq_params->enable_global_motion) {
use_global_motion = aom_rb_read_bit(rb);
}
if (!use_global_motion) {
@@ -6214,12 +6216,59 @@
}
return;
}
+
+ int our_ref = aom_rb_read_primitive_quniform(rb, num_total_refs + 1);
+ if (our_ref == num_total_refs) {
+ // Special case: Use IDENTITY model
+ cm->base_global_motion_model = default_warp_params;
+ cm->base_global_motion_distance = 1;
+ } else {
+ RefCntBuffer *buf = get_ref_frame_buf(cm, our_ref);
+ assert(buf);
+ int their_num_refs = buf->num_ref_frames;
+ if (their_num_refs == 0) {
+ // Special case: if an intra/key frame is used as a ref, use an
+ // IDENTITY model
+ cm->base_global_motion_model = default_warp_params;
+ cm->base_global_motion_distance = 1;
+ } else {
+ int their_ref = aom_rb_read_primitive_quniform(rb, their_num_refs);
+ cm->base_global_motion_model = buf->global_motion[their_ref];
+ cm->base_global_motion_distance =
+ get_relative_dist(&seq_params->order_hint_info, buf->order_hint,
+ buf->ref_order_hints[their_ref]);
+ }
+ }
#endif // CONFIG_IMPROVED_GLOBAL_MOTION
for (int frame = 0; frame < cm->ref_frames_info.num_total_refs; ++frame) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ int temporal_distance;
+ if (seq_params->order_hint_info.enable_order_hint) {
+ const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, frame);
+ temporal_distance = get_relative_dist(&seq_params->order_hint_info,
+ (int)cm->cur_frame->order_hint,
+ (int)ref_buf->order_hint);
+ } else {
+ temporal_distance = 1;
+ }
+
+ if (temporal_distance == 0) {
+ // Don't code global motion for frames at the same temporal instant
+ cm->global_motion[frame] = default_warp_params;
+ continue;
+ }
+
+ WarpedMotionParams ref_params_;
+ av1_scale_warp_model(&cm->base_global_motion_model,
+ cm->base_global_motion_distance, &ref_params_,
+ temporal_distance);
+ WarpedMotionParams *ref_params = &ref_params_;
+#else
const WarpedMotionParams *ref_params =
cm->prev_frame ? &cm->prev_frame->global_motion[frame]
: &default_warp_params;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
int good_params =
#if !CONFIG_FLEX_MVRES
read_global_motion_params(&cm->global_motion[frame], ref_params, rb,
@@ -6782,6 +6831,10 @@
features->allow_ref_frame_mvs = 0;
cm->prev_frame = NULL;
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = 0;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
} else {
features->allow_ref_frame_mvs = 0;
#if CONFIG_TIP
@@ -6807,6 +6860,10 @@
}
#endif // CONFIG_IBC_SR_EXT
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = 0;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
} else if (pbi->need_resync != 1) { /* Skip if need resync */
// Implicitly derive the reference mapping
RefFrameMapPair ref_frame_map_pairs[REF_FRAMES];
@@ -6887,6 +6944,9 @@
}
av1_get_past_future_cur_ref_lists(cm, scores);
}
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = cm->ref_frames_info.num_total_refs;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
if (!features->error_resilient_mode && frame_size_override_flag) {
setup_frame_size_with_refs(cm, rb);
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 2c94af4..afc3c26 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -4582,15 +4582,20 @@
static AOM_INLINE void write_global_motion(AV1_COMP *cpi,
struct aom_write_bit_buffer *wb) {
AV1_COMMON *const cm = &cpi->common;
+ int num_total_refs = cm->ref_frames_info.num_total_refs;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ assert(cm->cur_frame->num_ref_frames == num_total_refs);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
int frame;
#if CONFIG_IMPROVED_GLOBAL_MOTION
- if (!cm->seq_params.enable_global_motion) {
+ const SequenceHeader *const seq_params = &cm->seq_params;
+ if (!seq_params->enable_global_motion) {
return;
}
bool use_global_motion = false;
- for (frame = 0; frame < cm->ref_frames_info.num_total_refs; ++frame) {
+ for (frame = 0; frame < num_total_refs; ++frame) {
if (cm->global_motion[frame].wmtype != IDENTITY) {
use_global_motion = true;
break;
@@ -4601,12 +4606,58 @@
if (!use_global_motion) {
return;
}
+
+ int our_ref = cpi->gm_info.base_model_our_ref;
+ int their_ref = cpi->gm_info.base_model_their_ref;
+ aom_wb_write_primitive_quniform(wb, num_total_refs + 1, our_ref);
+ if (our_ref >= num_total_refs) {
+ // Special case: Use IDENTITY model
+ // Nothing more to code
+ assert(their_ref == -1);
+ } else {
+ RefCntBuffer *buf = get_ref_frame_buf(cm, our_ref);
+ assert(buf);
+ int their_num_refs = buf->num_ref_frames;
+ if (their_num_refs == 0) {
+ // Special case: if an intra/key frame is used as a ref, use an
+ // IDENTITY model
+ // Nothing more to code
+ assert(their_ref == -1);
+ } else {
+ aom_wb_write_primitive_quniform(wb, their_num_refs, their_ref);
+ }
+ }
#endif // CONFIG_IMPROVED_GLOBAL_MOTION
- for (frame = 0; frame < cm->ref_frames_info.num_total_refs; ++frame) {
+ for (frame = 0; frame < num_total_refs; ++frame) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ int temporal_distance;
+ if (seq_params->order_hint_info.enable_order_hint) {
+ const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, frame);
+ temporal_distance = get_relative_dist(&seq_params->order_hint_info,
+ (int)cm->cur_frame->order_hint,
+ (int)ref_buf->order_hint);
+ } else {
+ temporal_distance = 1;
+ }
+
+ if (temporal_distance == 0) {
+ // Don't code global motion for frames at the same temporal instant
+ assert(cm->global_motion[frame].wmtype == IDENTITY);
+ continue;
+ }
+
+ WarpedMotionParams ref_params_;
+ av1_scale_warp_model(&cm->base_global_motion_model,
+ cm->base_global_motion_distance, &ref_params_,
+ temporal_distance);
+ WarpedMotionParams *ref_params = &ref_params_;
+#else
const WarpedMotionParams *ref_params =
cm->prev_frame ? &cm->prev_frame->global_motion[frame]
: &default_warp_params;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
write_global_motion_params(&cm->global_motion[frame], ref_params, wb,
#if !CONFIG_FLEX_MVRES
cm->features.allow_high_precision_mv);
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index a931f84..2683de9 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -1105,6 +1105,9 @@
AOMMIN(cm->seq_params.num_same_ref_compound,
cm->ref_frames_info.num_total_refs);
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = cm->ref_frames_info.num_total_refs;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
// ref_frame_flags is defined based on the external flag
// max-reference-frames.
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 4b68d58..c272ed9 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -1978,6 +1978,25 @@
int segment_map_w; /*!< segment map width */
int segment_map_h; /*!< segment map height */
/**@}*/
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ /*!
+ * \brief Error ratio for each selected global motion model
+ *
+ * This is used to help decide which models will actually be used,
+ * because that decision has to be deferred until we actually select a
+ * base model to use
+ */
+ double erroradvantage[INTER_REFS_PER_FRAME];
+
+ /**
+ * \name Reference path for selected base model
+ */
+ /**@{*/
+ int base_model_our_ref; /*!< which of our ref frames to copy from */
+ int base_model_their_ref; /*!< which model to copy from that frame */
+ /**@}*/
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
} GlobalMotionInfo;
/*!
diff --git a/av1/encoder/global_motion_facade.c b/av1/encoder/global_motion_facade.c
index 69b725c..648ca60 100644
--- a/av1/encoder/global_motion_facade.c
+++ b/av1/encoder/global_motion_facade.c
@@ -106,14 +106,25 @@
// For the given reference frame, computes the global motion parameters for
// different motion models and finds the best.
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+static AOM_INLINE void compute_global_motion_for_ref_frame(
+ AV1_COMP *cpi, YV12_BUFFER_CONFIG *ref_buf[INTER_REFS_PER_FRAME], int frame,
+ MotionModel *motion_models, uint8_t *segment_map, const int segment_map_w,
+ const int segment_map_h) {
+#else
static AOM_INLINE void compute_global_motion_for_ref_frame(
AV1_COMP *cpi, YV12_BUFFER_CONFIG *ref_buf[INTER_REFS_PER_FRAME], int frame,
MotionModel *motion_models, uint8_t *segment_map, const int segment_map_w,
const int segment_map_h, const WarpedMotionParams *ref_params) {
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
ThreadData *const td = &cpi->td;
MACROBLOCK *const x = &td->mb;
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ GlobalMotionInfo *const gm_info = &cpi->gm_info;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
int i;
int src_width = cpi->source->y_crop_width;
int src_height = cpi->source->y_crop_height;
@@ -204,6 +215,12 @@
if (tmp_wm_params.wmtype == IDENTITY) continue;
#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // Apply initial quality filter, which depends only on the error metrics
+ // and not the model cost
+ if (warp_error >= ref_frame_error * erroradv_tr) continue;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
if (warp_error < best_warp_error) {
best_ref_frame_error = ref_frame_error;
best_warp_error = warp_error;
@@ -246,6 +263,12 @@
// ref_frame_error == 0
assert(best_ref_frame_error > 0);
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ gm_info->erroradvantage[frame] =
+ (double)best_warp_error / best_ref_frame_error;
+
+ break;
+#else
// If the best error advantage found doesn't meet the threshold for
// this motion type, revert to IDENTITY.
if (!av1_is_enough_erroradvantage(
@@ -260,6 +283,7 @@
}
if (cm->global_motion[frame].wmtype != IDENTITY) break;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
}
aom_free_flow_data(flow_data);
@@ -271,6 +295,11 @@
AV1_COMP *cpi, YV12_BUFFER_CONFIG *ref_buf[INTER_REFS_PER_FRAME], int frame,
MotionModel *motion_models, uint8_t *segment_map, int segment_map_w,
int segment_map_h) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ compute_global_motion_for_ref_frame(cpi, ref_buf, frame, motion_models,
+ segment_map, segment_map_w,
+ segment_map_h);
+#else
AV1_COMMON *const cm = &cpi->common;
const WarpedMotionParams *ref_params =
cm->prev_frame ? &cm->prev_frame->global_motion[frame]
@@ -279,6 +308,7 @@
compute_global_motion_for_ref_frame(cpi, ref_buf, frame, motion_models,
segment_map, segment_map_w, segment_map_h,
ref_params);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
}
// Loops over valid reference frames and computes global motion estimation.
@@ -445,6 +475,150 @@
return true;
}
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+// Select which global motion model to use as a base
+static AOM_INLINE void pick_base_gm_params(AV1_COMP *cpi) {
+ AV1_COMMON *const cm = &cpi->common;
+ const SequenceHeader *const seq_params = &cm->seq_params;
+ GlobalMotionInfo *const gm_info = &cpi->gm_info;
+ int num_total_refs = cm->ref_frames_info.num_total_refs;
+
+ int best_our_ref;
+ int best_their_ref;
+ const WarpedMotionParams *best_base_model;
+ int best_temporal_distance;
+ int best_num_models;
+ int best_cost;
+
+ // Bitmask of which models we will actually use if we accept the current
+ // best base model
+ uint8_t best_enable_models;
+
+ // First, evaluate the identity model as a base
+ {
+ int this_num_models = 0;
+ int this_cost =
+ aom_count_primitive_quniform(num_total_refs + 1, num_total_refs)
+ << AV1_PROB_COST_SHIFT;
+ uint8_t this_enable_models = 0;
+
+ for (int frame = 0; frame < num_total_refs; frame++) {
+ const WarpedMotionParams *model = &cm->global_motion[frame];
+ if (model->wmtype == IDENTITY) continue;
+
+ int model_cost = gm_get_params_cost(model, &default_warp_params,
+ cm->features.fr_mv_precision);
+ bool use_model = av1_is_enough_erroradvantage(
+ gm_info->erroradvantage[frame], model_cost);
+
+ if (use_model) {
+ this_num_models += 1;
+ this_cost += model_cost;
+ this_enable_models |= (1 << frame);
+ }
+ }
+
+ // Set initial values
+ best_our_ref = cm->ref_frames_info.num_total_refs;
+ best_their_ref = -1;
+ best_base_model = &default_warp_params;
+ best_temporal_distance = 1;
+ best_num_models = this_num_models;
+ best_cost = this_cost;
+ best_enable_models = this_enable_models;
+ }
+
+ // Then try each available reference model in turn
+ for (int our_ref = 0; our_ref < num_total_refs; ++our_ref) {
+ const int ref_disabled = !(cm->ref_frame_flags & (1 << our_ref));
+ RefCntBuffer *buf = get_ref_frame_buf(cm, our_ref);
+ // Skip looking at invalid ref frames
+ if (buf == NULL ||
+ (ref_disabled && cpi->sf.hl_sf.recode_loop != DISALLOW_RECODE)) {
+ continue;
+ }
+
+ int their_num_refs = buf->num_ref_frames;
+ for (int their_ref = 0; their_ref < their_num_refs; ++their_ref) {
+ const WarpedMotionParams *base_model = &buf->global_motion[their_ref];
+ if (base_model->wmtype == IDENTITY) {
+ continue;
+ }
+
+ int base_temporal_distance =
+ get_relative_dist(&seq_params->order_hint_info, buf->order_hint,
+ buf->ref_order_hints[their_ref]);
+
+ int this_num_models = 0;
+ int this_cost =
+ (aom_count_primitive_quniform(num_total_refs + 1, our_ref) +
+ aom_count_primitive_quniform(their_num_refs, their_ref))
+ << AV1_PROB_COST_SHIFT;
+ uint8_t this_enable_models = 0;
+
+ for (int frame = 0; frame < num_total_refs; frame++) {
+ const WarpedMotionParams *model = &cm->global_motion[frame];
+ if (model->wmtype == IDENTITY) continue;
+
+ int temporal_distance;
+ if (seq_params->order_hint_info.enable_order_hint) {
+ const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, frame);
+ temporal_distance = get_relative_dist(&seq_params->order_hint_info,
+ (int)cm->cur_frame->order_hint,
+ (int)ref_buf->order_hint);
+ } else {
+ temporal_distance = 1;
+ }
+
+ if (temporal_distance == 0) {
+ // Don't code global motion for frames at the same temporal instant
+ assert(model->wmtype == IDENTITY);
+ continue;
+ }
+
+ WarpedMotionParams ref_params;
+ av1_scale_warp_model(base_model, base_temporal_distance, &ref_params,
+ temporal_distance);
+
+ int model_cost = gm_get_params_cost(model, &ref_params,
+ cm->features.fr_mv_precision);
+ bool use_model = av1_is_enough_erroradvantage(
+ gm_info->erroradvantage[frame], model_cost);
+
+ if (use_model) {
+ this_num_models += 1;
+ this_cost += model_cost;
+ this_enable_models |= (1 << frame);
+ }
+ }
+
+ if (this_num_models > best_num_models ||
+ (this_num_models == best_num_models && this_cost < best_cost)) {
+ best_our_ref = our_ref;
+ best_their_ref = their_ref;
+ best_base_model = base_model;
+ best_temporal_distance = base_temporal_distance;
+ best_num_models = this_num_models;
+ best_cost = this_cost;
+ best_enable_models = this_enable_models;
+ }
+ }
+ }
+
+ gm_info->base_model_our_ref = best_our_ref;
+ gm_info->base_model_their_ref = best_their_ref;
+ cm->base_global_motion_model = *best_base_model;
+ cm->base_global_motion_distance = best_temporal_distance;
+
+ for (int frame = 0; frame < num_total_refs; frame++) {
+ if ((best_enable_models & (1 << frame)) == 0) {
+ // Disable this model
+ cm->global_motion[frame] = default_warp_params;
+ }
+ }
+}
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
// Initializes parameters used for computing global motion.
static AOM_INLINE void setup_global_motion_info_params(AV1_COMP *cpi) {
GlobalMotionInfo *const gm_info = &cpi->gm_info;
@@ -544,6 +718,12 @@
else
global_motion_estimation(cpi);
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // Once we have determined the best motion model for each ref frame,
+ // choose the base parameters to minimize the total encoding cost
+ pick_base_gm_params(cpi);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
// Check if the current frame has any valid global motion model across its
// reference frames
if (cpi->sf.gm_sf.disable_gm_search_based_on_stats) {
