[PATCH libinput 2/4] filter: add a custom trackpoint accelerator

Peter Hutterer peter.hutterer at who-t.net
Wed Jul 12 06:06:16 UTC 2017


Switch to a pure factor with a max scaled after a function. The offset is just
0 now (will be removed eventually). Both are determined with a function based
on a linear/exponential regression of a sample set of data pairs.

Signed-off-by: Peter Hutterer <peter.hutterer at who-t.net>
---
 doc/pointer-acceleration.dox |  16 ++-
 src/evdev.c                  |   8 +-
 src/evdev.h                  |   1 +
 src/filter.c                 | 293 ++++++++++++++++++++++++++++++++++++-------
 src/filter.h                 |   5 +-
 tools/ptraccel-debug.c       |  38 +++++-
 6 files changed, 301 insertions(+), 60 deletions(-)

diff --git a/doc/pointer-acceleration.dox b/doc/pointer-acceleration.dox
index f6237c6b..57be6cdc 100644
--- a/doc/pointer-acceleration.dox
+++ b/doc/pointer-acceleration.dox
@@ -109,9 +109,16 @@ The image above shows the touchpad acceleration profile in comparison to the
 
 @section ptraccel-trackpoint Pointer acceleration on trackpoints
 
-Trackpoint hardware is quite varied in how it reacts to user pressure and
-unlike other devices it cannot easily be normalized for physical properties.
-Measuring pressure objectively across a variety of hardware is nontrivial.
+The main difference between trackpoint hardware and mice or touchpads is
+that trackpoint speed is a function of pressure rather than moving speed.
+But trackpoint hardware is quite varied in how it reacts to user pressure
+and unlike other devices it cannot easily be normalized for physical
+properties. Measuring pressure objectively across a variety of hardware is
+nontrivial.
+
+libinput's pointer acceleration is a function of the total available
+pressure range on a device.
+
 libinput relies on some sytem-wide configured properties, specifically the
 @ref udev_config. The two properties that influence trackpoint acceleration
 ````POINTINGSTICK_CONST_ACCEL```` which is a constant factor applied to the
@@ -125,9 +132,6 @@ builtin is expected to apply this to the device, i.e.  libinput does not
 handle this property. Once applied, the sensitivity adjusts the deltas
 coming out of the hardware.
 
-Trackpoint pointer acceleration uses the @ref ptraccel-low-dpi profile, with a
-constant acceleration factor taking the place of the DPI settings.
-
 @image html ptraccel-trackpoint.svg "Pointer acceleration curves for trackpoints"
 
 The image above shows the trackpoint acceleration profile in comparison to the
diff --git a/src/evdev.c b/src/evdev.c
index 0d861190..e07d5f7e 100644
--- a/src/evdev.c
+++ b/src/evdev.c
@@ -1990,7 +1990,7 @@ evdev_init_accel(struct evdev_device *device,
 	if (which == LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT)
 		filter = create_pointer_accelerator_filter_flat(device->dpi);
 	else if (device->tags & EVDEV_TAG_TRACKPOINT)
-		filter = create_pointer_accelerator_filter_trackpoint(device->dpi);
+		filter = create_pointer_accelerator_filter_trackpoint(device->trackpoint_range);
 	else if (device->dpi < DEFAULT_MOUSE_DPI)
 		filter = create_pointer_accelerator_filter_linear_low_dpi(device->dpi);
 	else
@@ -2213,6 +2213,10 @@ evdev_get_trackpoint_dpi(struct evdev_device *device)
 	const char *trackpoint_accel;
 	double accel = DEFAULT_TRACKPOINT_ACCEL;
 
+	/*
+	 * parse the sensitivity property, and undo whatever it does.
+	 */
+
 	trackpoint_accel = udev_device_get_property_value(
 				device->udev_device, "POINTINGSTICK_CONST_ACCEL");
 	if (trackpoint_accel) {
@@ -2227,6 +2231,8 @@ evdev_get_trackpoint_dpi(struct evdev_device *device)
 		evdev_log_info(device, "set to const accel %.2f\n", accel);
 	}
 
+	device->trackpoint_range = 20; /* FIXME */
+
 	return DEFAULT_MOUSE_DPI / accel;
 }
 
diff --git a/src/evdev.h b/src/evdev.h
index b891f906..6524adf0 100644
--- a/src/evdev.h
+++ b/src/evdev.h
@@ -158,6 +158,7 @@ struct evdev_device {
 	bool is_mt;
 	bool is_suspended;
 	int dpi; /* HW resolution */
+	int trackpoint_range; /* trackpoint max delta */
 	struct ratelimit syn_drop_limit; /* ratelimit for SYN_DROPPED logging */
 	struct ratelimit nonpointer_rel_limit; /* ratelimit for REL_* events from non-pointer devices */
 	uint32_t model_flags;
diff --git a/src/filter.c b/src/filter.c
index 65e83197..022a7040 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -147,6 +147,12 @@ filter_get_type(struct motion_filter *filter)
 #define X230_MAGIC_SLOWDOWN 0.4			/* unitless */
 #define X230_TP_MAGIC_LOW_RES_FACTOR 4.0	/* unitless */
 
+/* Trackpoint acceleration */
+#define TRACKPOINT_DEFAULT_MAX_ACCEL 2.0	/* in units/us */
+#define TRACKPOINT_DEFAULT_MAX_DELTA 60
+/* As measured on a Lenovo T440 at kernel-default sensitivity 128 */
+#define TRACKPOINT_DEFAULT_RANGE 20		/* max value */
+
 /*
  * Pointer acceleration filter constants
  */
@@ -195,6 +201,20 @@ struct tablet_accelerator_flat {
 	       yres_scale; /* 1000dpi : tablet res */
 };
 
+struct trackpoint_accelerator {
+	struct motion_filter base;
+
+	struct device_float_coords history[4];
+	size_t history_size;
+
+	double scale_factor;
+	double max_accel;
+	double max_delta;
+
+	double incline; /* incline of the function */
+	double offset; /* offset of the function */
+};
+
 static void
 feed_trackers(struct pointer_accelerator *accel,
 	      const struct device_float_coords *delta,
@@ -904,38 +924,6 @@ touchpad_lenovo_x230_accel_profile(struct motion_filter *filter,
 	return factor * X230_MAGIC_SLOWDOWN / X230_TP_MAGIC_LOW_RES_FACTOR;
 }
 
-double
-trackpoint_accel_profile(struct motion_filter *filter,
-				void *data,
-				double speed_in, /* device units/┬Ás */
-				uint64_t time)
-{
-	struct pointer_accelerator *accel_filter =
-		(struct pointer_accelerator *)filter;
-	double max_accel = accel_filter->accel; /* unitless factor */
-	double threshold = accel_filter->threshold; /* units/ms */
-	const double incline = accel_filter->incline;
-	double dpi_factor = accel_filter->dpi/(double)DEFAULT_MOUSE_DPI;
-	double factor;
-
-	/* dpi_factor is always < 1.0, increase max_accel, reduce
-	   the threshold so it kicks in earlier */
-	max_accel /= dpi_factor;
-	threshold *= dpi_factor;
-
-	/* see pointer_accel_profile_linear for a long description */
-	if (v_us2ms(speed_in) < 0.07)
-		factor = 10 * v_us2ms(speed_in) + 0.3;
-	else if (speed_in < threshold)
-		factor = 1;
-	else
-		factor = incline * v_us2ms(speed_in - threshold) + 1;
-
-	factor = min(max_accel, factor);
-
-	return factor;
-}
-
 struct motion_filter_interface accelerator_interface = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
 	.filter = accelerator_filter_pre_normalized,
@@ -1063,30 +1051,245 @@ create_pointer_accelerator_filter_lenovo_x230(int dpi)
 	return &filter->base;
 }
 
+double
+trackpoint_accel_profile(struct motion_filter *filter,
+			 void *data,
+			 double delta)
+{
+	struct trackpoint_accelerator *accel_filter =
+		(struct trackpoint_accelerator *)filter;
+	const double max_accel = accel_filter->max_accel;
+	double factor;
+
+	delta = fabs(delta);
+
+	/* This is almost the equivalent of the xserver acceleration
+	   at sensitivity 128 and speed 0.0 */
+	factor = delta * accel_filter->incline + accel_filter->offset;
+	factor = min(factor, max_accel);
+
+	return factor;
+}
+
+/**
+ * Average the deltas, they are messy and can provide sequences like 7, 7,
+ * 9, 8, 14, 7, 9, 8 ... The outliers cause unpredictable jumps, so average
+ * them out.
+ */
+static inline struct device_float_coords
+trackpoint_average_delta(struct trackpoint_accelerator *filter,
+			 const struct device_float_coords *unaccelerated)
+{
+	size_t i;
+	struct device_float_coords avg;
+
+	memmove(&filter->history[1],
+		&filter->history[0],
+		sizeof(*filter->history) * (filter->history_size - 1));
+	filter->history[0] = *unaccelerated;
+
+	for (i = 0; i < filter->history_size; i++) {
+		avg.x += filter->history[i].x;
+		avg.y += filter->history[i].y;
+	}
+	avg.x /= filter->history_size;
+	avg.y /= filter->history_size;
+
+	return avg;
+}
+
+/**
+ * Undo any system-wide magic scaling, so we're behaving the same regardless
+ * of the trackpoint hardware. This way we can apply our profile independent
+ * of any other configuration that messes with things.
+ */
+static inline struct device_float_coords
+trackpoint_normalize_deltas(const struct trackpoint_accelerator *accel_filter,
+			    const struct device_float_coords *delta)
+{
+	struct device_float_coords scaled = *delta;
+
+	scaled.x *= accel_filter->scale_factor;
+	scaled.y *= accel_filter->scale_factor;
+
+	return scaled;
+}
+
+/**
+ * We set a max delta per event, to avoid extreme jumps once we exceed the
+ * expected pressure. Trackpoint hardware is inconsistent once the pressure
+ * gets high, so we can expect sequences like 30, 40, 35, 55, etc. This may
+ * be caused by difficulty keeping up high consistent pressures or just
+ * measuring errors in the hardware. Either way, we cap to a max delta so
+ * once we hit the high pressures, movement is capped and consistent.
+ */
+static inline struct normalized_coords
+trackpoint_clip_to_max_delta(const struct trackpoint_accelerator *accel_filter,
+			     struct normalized_coords coords)
+{
+	const double max_delta = accel_filter->max_delta;
+
+	if (abs(coords.x) > max_delta)
+		coords.x = copysign(max_delta, coords.x);
+	if (abs(coords.y) > max_delta)
+		coords.y = copysign(max_delta, coords.y);
+
+	return coords;
+}
+
+static struct normalized_coords
+trackpoint_accelerator_filter(struct motion_filter *filter,
+			      const struct device_float_coords *unaccelerated,
+			      void *data, uint64_t time)
+{
+	struct trackpoint_accelerator *accel_filter =
+		(struct trackpoint_accelerator *)filter;
+	struct device_float_coords scaled;
+	struct device_float_coords avg;
+	struct normalized_coords coords;
+	double f;
+	double delta;
+
+	scaled = trackpoint_normalize_deltas(accel_filter, unaccelerated);
+	avg = trackpoint_average_delta(accel_filter, &scaled);
+
+	delta = hypot(avg.x, avg.y);
+
+	f = trackpoint_accel_profile(filter, data, delta);
+
+	coords.x = avg.x * f;
+	coords.y = avg.y * f;
+
+	coords = trackpoint_clip_to_max_delta(accel_filter, coords);
+
+	return coords;
+}
+
+static struct normalized_coords
+trackpoint_accelerator_filter_noop(struct motion_filter *filter,
+				   const struct device_float_coords *unaccelerated,
+				   void *data, uint64_t time)
+{
+
+	struct trackpoint_accelerator *accel_filter =
+		(struct trackpoint_accelerator *)filter;
+	struct device_float_coords scaled;
+	struct device_float_coords avg;
+	struct normalized_coords coords;
+
+	scaled = trackpoint_normalize_deltas(accel_filter, unaccelerated);
+	avg = trackpoint_average_delta(accel_filter, &scaled);
+
+	coords.x = avg.x;
+	coords.y = avg.y;
+
+	coords = trackpoint_clip_to_max_delta(accel_filter, coords);
+
+	return coords;
+}
+
+static bool
+trackpoint_accelerator_set_speed(struct motion_filter *filter,
+				 double speed_adjustment)
+{
+	struct trackpoint_accelerator *accel_filter =
+		(struct trackpoint_accelerator*)filter;
+	double incline, offset, max;
+
+	assert(speed_adjustment >= -1.0 && speed_adjustment <= 1.0);
+
+	/* Helloooo, magic numbers.
+
+	   These numbers were obtained by finding an acceleration curve that
+	   provides precision at slow speeds but still provides a good
+	   acceleration at higher pressure - and a quick ramp-up to that
+	   acceleration.
+
+	   Trackpoints have built-in acceleration curves already, so we
+	   don't put a new function on top, we merely scale the output from
+	   those curves (re-calculating the pressure values from the
+	   firmware-defined curve and applying a new curve is unreliable).
+
+	   For that basic scaling, we assume a constant factor f based on
+	   the speed setting together with a maximum factor m (for this
+	   speed setting). Delta acceleration is thus:
+	      factor = max(m, f)
+	      accelerated_delta = delta * factor;
+
+	   Trial and error showed a couple of pairs that work well for the
+	   various speed settings (Lenovo T440, sensitivity 128):
+
+	       -1.0: f = 0.3, m = 1
+	       -0.5: f = 0.6, m = 2
+	        0.0: f = 1.0, m = 6
+	        0.5: f = 1.4, m = 8
+	        1.0: f = 1.9, m = 15
+
+	   Note: if f >= 2.0, some pixels are unaddressable
+
+	   Those pairs were fed into the linear/exponential regression tool
+	   at http://www.xuru.org/rt/LR.asp and show two functions that map
+	   speed settings to the respective f and m.
+	   Given a speed setting s in [-1.0, 1.0]
+		   f(s) = 0.8 * s + 1.04
+		   m(s) = 4.6 * e**(1.2 * s)
+	   These are close enough to the tested pairs.
+	*/
+
+	max = 4.6 * pow(M_E, 1.2 * speed_adjustment);
+	incline = 0.8 * speed_adjustment + 1.04;
+	offset = 0;
+
+	accel_filter->max_accel = max;
+	accel_filter->incline = incline;
+	accel_filter->offset = offset;
+	filter->speed_adjustment = speed_adjustment;
+
+	return true;
+}
+
+static void
+trackpoint_accelerator_destroy(struct motion_filter *filter)
+{
+	struct trackpoint_accelerator *accel_filter =
+		(struct trackpoint_accelerator *)filter;
+
+	free(accel_filter);
+}
+
 struct motion_filter_interface accelerator_interface_trackpoint = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
-	.filter = accelerator_filter_unnormalized,
-	.filter_constant = accelerator_filter_noop,
-	.restart = accelerator_restart,
-	.destroy = accelerator_destroy,
-	.set_speed = accelerator_set_speed,
+	.filter = trackpoint_accelerator_filter,
+	.filter_constant = trackpoint_accelerator_filter_noop,
+	.restart = NULL,
+	.destroy = trackpoint_accelerator_destroy,
+	.set_speed = trackpoint_accelerator_set_speed,
 };
 
 struct motion_filter *
-create_pointer_accelerator_filter_trackpoint(int dpi)
+create_pointer_accelerator_filter_trackpoint(int max_hw_delta)
 {
-	struct pointer_accelerator *filter;
+	struct trackpoint_accelerator *filter;
 
-	filter = create_default_filter(dpi);
+	/* Trackpoints are special. They don't have a movement speed like a
+	 * mouse or a finger, instead they send a constant stream of events
+	 * based on the pressure applied.
+	 *
+	 * Physical ranges on a trackpoint are the max values for relative
+	 * deltas, but these are highly device-specific.
+	 *
+	 */
+
+	filter = zalloc(sizeof *filter);
 	if (!filter)
 		return NULL;
 
+	filter->history_size = ARRAY_LENGTH(filter->history);
+	filter->scale_factor = 1.0 * TRACKPOINT_DEFAULT_RANGE / max_hw_delta;
+	filter->max_accel = TRACKPOINT_DEFAULT_MAX_ACCEL;
+	filter->max_delta = TRACKPOINT_DEFAULT_MAX_DELTA;
+
 	filter->base.interface = &accelerator_interface_trackpoint;
-	filter->profile = trackpoint_accel_profile;
-	filter->threshold = DEFAULT_THRESHOLD;
-	filter->accel = DEFAULT_ACCELERATION;
-	filter->incline = DEFAULT_INCLINE;
-	filter->dpi = dpi;
 
 	return &filter->base;
 }
diff --git a/src/filter.h b/src/filter.h
index e24c20d4..60d3728a 100644
--- a/src/filter.h
+++ b/src/filter.h
@@ -120,7 +120,7 @@ struct motion_filter *
 create_pointer_accelerator_filter_lenovo_x230(int dpi);
 
 struct motion_filter *
-create_pointer_accelerator_filter_trackpoint(int dpi);
+create_pointer_accelerator_filter_trackpoint(int max_delta);
 
 struct motion_filter *
 create_pointer_accelerator_filter_tablet(int xres, int yres);
@@ -152,6 +152,5 @@ touchpad_lenovo_x230_accel_profile(struct motion_filter *filter,
 double
 trackpoint_accel_profile(struct motion_filter *filter,
 			 void *data,
-			 double speed_in,
-			 uint64_t time);
+			 double delta);
 #endif /* FILTER_H */
diff --git a/tools/ptraccel-debug.c b/tools/ptraccel-debug.c
index acb82c69..052769be 100644
--- a/tools/ptraccel-debug.c
+++ b/tools/ptraccel-debug.c
@@ -170,6 +170,24 @@ print_accel_func(struct motion_filter *filter,
 }
 
 static void
+print_accel_func_trackpoint(struct motion_filter *filter,
+			    int max)
+{
+	printf("# gnuplot:\n");
+	printf("# set xlabel \"deltas (units)\"\n");
+	printf("# set ylabel \"raw accel factor\"\n");
+	printf("# set style data lines\n");
+	printf("# plot \"gnuplot.data\" using 1:2 title 'accel factor'\n");
+	printf("#\n");
+	printf("# data: delta(units) factor\n");
+	for (double delta = 0; delta < max; delta += 0.2) {
+		double factor = trackpoint_accel_profile(filter, NULL, delta);
+
+		printf("%.2f %f\n", delta, factor);
+	}
+}
+
+static void
 usage(void)
 {
 	printf("Usage: %s [options] [dx1] [dx2] [...] > gnuplot.data\n", program_invocation_short_name);
@@ -184,6 +202,7 @@ usage(void)
 	       "--steps=<double>  ... in motion and delta modes only. Increase dx by step each round\n"
 	       "--speed=<double>  ... accel speed [-1, 1], default 0\n"
 	       "--dpi=<int>	... device resolution in DPI (default: 1000)\n"
+	       "--trackpoint_range=<int> ... range of the trackpoint deltas (default: 30)\n"
 	       "--filter=<linear|low-dpi|touchpad|x230|trackpoint> \n"
 	       "	linear	  ... the default motion filter\n"
 	       "	low-dpi	  ... low-dpi filter, use --dpi with this argument\n"
@@ -219,6 +238,7 @@ main(int argc, char **argv)
 	int dpi = 1000;
 	const char *filter_type = "linear";
 	accel_profile_func_t profile = NULL;
+	int tp_range_max = 20;
 
 	enum {
 		OPT_HELP = 1,
@@ -229,6 +249,7 @@ main(int argc, char **argv)
 		OPT_SPEED,
 		OPT_DPI,
 		OPT_FILTER,
+		OPT_TRACKPOINT_RANGE,
 	};
 
 	while (1) {
@@ -243,6 +264,7 @@ main(int argc, char **argv)
 			{"speed", 1, 0, OPT_SPEED },
 			{"dpi", 1, 0, OPT_DPI },
 			{"filter", 1, 0, OPT_FILTER },
+			{"trackpoint-range", 1, 0, OPT_TRACKPOINT_RANGE },
 			{0, 0, 0, 0}
 		};
 
@@ -300,6 +322,9 @@ main(int argc, char **argv)
 		case OPT_FILTER:
 			filter_type = optarg;
 			break;
+		case OPT_TRACKPOINT_RANGE:
+			tp_range_max = strtod(optarg, NULL);
+			break;
 		default:
 			usage();
 			exit(1);
@@ -320,8 +345,8 @@ main(int argc, char **argv)
 		filter = create_pointer_accelerator_filter_lenovo_x230(dpi);
 		profile = touchpad_lenovo_x230_accel_profile;
 	} else if (streq(filter_type, "trackpoint")) {
-		filter = create_pointer_accelerator_filter_trackpoint(dpi);
-		profile = trackpoint_accel_profile;
+		filter = create_pointer_accelerator_filter_trackpoint(tp_range_max);
+		profile = NULL; /* trackpoint is special */
 	} else {
 		fprintf(stderr, "Invalid filter type %s\n", filter_type);
 		return 1;
@@ -349,9 +374,12 @@ main(int argc, char **argv)
 			custom_deltas[nevents++] = strtod(argv[optind++], NULL);
 	}
 
-	if (print_accel)
-		print_accel_func(filter, profile, dpi);
-	else if (print_delta)
+	if (print_accel) {
+		if (!profile) /* trackpoint */
+			print_accel_func_trackpoint(filter, tp_range_max);
+		else
+			print_accel_func(filter, profile, dpi);
+	} else if (print_delta)
 		print_ptraccel_deltas(filter, step);
 	else if (print_motion)
 		print_ptraccel_movement(filter, nevents, max_dx, step);
-- 
2.13.0



More information about the wayland-devel mailing list