filter: remove an unnecessary layer of indirection

This is a leftover from when some of the filter code was shared between
pointer acceleration methods (pre v1.11 or so). Now these functions are
duplicated across files, so both the names and what they do isn't
necessarily reflective anymore.

Let's drop one layer of indirection to make the code a bit easier to
understand.

No functional changes.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

diff --git a/src/filter-low-dpi.c b/src/filter-low-dpi.c
index ce77c5c33a9c33efbf37dffb330faf2e5dcab7c8..ea35656ce8a974c3a5c49fb15b6d4c8358b687b8 100644 (file)
--- a/src/filter-low-dpi.c
+++ b/src/filter-low-dpi.c
@@ -125,42 +125,23 @@ calculate_acceleration_factor(struct pointer_accelerator_low_dpi *accel,
        return accel_factor;
 }
 
-static struct device_float_coords
-accelerator_filter_generic(struct motion_filter *filter,
+static struct normalized_coords
+accelerator_filter_low_dpi(struct motion_filter *filter,
                           const struct device_float_coords *unaccelerated,
                           void *data, uint64_t time)
 {
        struct pointer_accelerator_low_dpi *accel =
                (struct pointer_accelerator_low_dpi *) filter;
-       double accel_value; /* unitless factor */
-       struct device_float_coords accelerated;
-
-       accel_value = calculate_acceleration_factor(accel,
-                                                   unaccelerated,
-                                                   data,
-                                                   time);
-
-       accelerated.x = accel_value * unaccelerated->x;
-       accelerated.y = accel_value * unaccelerated->y;
-
-       return accelerated;
-}
-
-static struct normalized_coords
-accelerator_filter_unnormalized(struct motion_filter *filter,
-                               const struct device_float_coords *unaccelerated,
-                               void *data, uint64_t time)
-{
-       struct device_float_coords accelerated;
-       struct normalized_coords normalized;
 
        /* Accelerate for device units and return device units */
-       accelerated = accelerator_filter_generic(filter,
-                                                unaccelerated,
-                                                data,
-                                                time);
-       normalized.x = accelerated.x;
-       normalized.y = accelerated.y;
+       double accel_factor = calculate_acceleration_factor(accel,
+                                                           unaccelerated,
+                                                           data,
+                                                           time);
+       const struct normalized_coords normalized = {
+               .x = accel_factor * unaccelerated->x,
+               .y = accel_factor * unaccelerated->y,
+       };
        return normalized;
 }
 
@@ -226,7 +207,7 @@ accelerator_set_speed(struct motion_filter *filter,
 
 struct motion_filter_interface accelerator_interface_low_dpi = {
        .type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
-       .filter = accelerator_filter_unnormalized,
+       .filter = accelerator_filter_low_dpi,
        .filter_constant = accelerator_filter_noop,
        .restart = accelerator_restart,
        .destroy = accelerator_destroy,

diff --git a/src/filter-mouse.c b/src/filter-mouse.c
index 18bb3d4376f1c229c6ba5e49bce42ced10045d81..aa56a050448125abacf8d1bf370eaee707b88950 100644 (file)
--- a/src/filter-mouse.c
+++ b/src/filter-mouse.c
@@ -99,55 +99,25 @@ calculate_acceleration_factor(struct pointer_accelerator *accel,
        return accel_factor;
 }
 
-/**
- * Generic filter that calculates the acceleration factor and applies it to
- * the coordinates.
- *
- * @param filter The acceleration filter
- * @param unaccelerated The raw delta in the device's dpi
- * @param data Caller-specific data
- * @param time Current time in µs
- *
- * @return An accelerated tuple of coordinates representing accelerated
- * motion, still in device units.
- */
 static struct normalized_coords
-accelerator_filter_generic(struct motion_filter *filter,
-                          const struct normalized_coords *unaccelerated,
-                          void *data, uint64_t time)
+accelerator_filter_linear(struct motion_filter *filter,
+                         const struct device_float_coords *unaccelerated,
+                         void *data, uint64_t time)
 {
        struct pointer_accelerator *accel =
                (struct pointer_accelerator *) filter;
-       double accel_value; /* unitless factor */
-       struct normalized_coords accelerated;
-
-       accel_value = calculate_acceleration_factor(accel,
-                                                   unaccelerated,
-                                                   data,
-                                                   time);
 
-       accelerated.x = accel_value * unaccelerated->x;
-       accelerated.y = accel_value * unaccelerated->y;
-
-       return accelerated;
-}
-
-static struct normalized_coords
-accelerator_filter_pre_normalized(struct motion_filter *filter,
-                                 const struct device_float_coords *unaccelerated,
-                                 void *data, uint64_t time)
-{
-       struct pointer_accelerator *accel =
-               (struct pointer_accelerator *) filter;
-       struct normalized_coords normalized, accelerated;
-
-       /* Accelerate for normalized units and return normalized units.
-          API requires device_floats, so we just copy the bits around */
-       normalized = normalize_for_dpi(unaccelerated, accel->dpi);
-       accelerated = accelerator_filter_generic(filter,
-                                                &normalized,
-                                                data,
-                                                time);
+       /* Accelerate for normalized units and return normalized units */
+       const struct normalized_coords normalized = normalize_for_dpi(unaccelerated,
+                                                                     accel->dpi);
+       double accel_factor = calculate_acceleration_factor(accel,
+                                                           &normalized,
+                                                           data,
+                                                           time);
+       struct normalized_coords accelerated = {
+               .x = normalized.x * accel_factor,
+               .y = normalized.y * accel_factor,
+       };
        return accelerated;
 }
 
@@ -301,7 +271,7 @@ pointer_accel_profile_linear(struct motion_filter *filter,
 
 struct motion_filter_interface accelerator_interface = {
        .type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
-       .filter = accelerator_filter_pre_normalized,
+       .filter = accelerator_filter_linear,
        .filter_constant = accelerator_filter_noop,
        .restart = accelerator_restart,
        .destroy = accelerator_destroy,

diff --git a/src/filter-touchpad.c b/src/filter-touchpad.c
index 0d1021a72836b43fff6a05ef15582d7743202c95..e8bc8c587714818fd5875d53a240188c70ea9858 100644 (file)
--- a/src/filter-touchpad.c
+++ b/src/filter-touchpad.c
@@ -90,53 +90,24 @@ calculate_acceleration_factor(struct touchpad_accelerator *accel,
        return accel_factor;
 }
 
-/**
- * Generic filter that calculates the acceleration factor and applies it to
- * the coordinates.
- *
- * @param filter The acceleration filter
- * @param unaccelerated The raw delta in the device's dpi
- * @param data Caller-specific data
- * @param time Current time in µs
- *
- * @return An accelerated tuple of coordinates representing accelerated
- * motion, still in device units.
- */
-static struct device_float_coords
-accelerator_filter_generic(struct motion_filter *filter,
-                          const struct device_float_coords *unaccelerated,
-                          void *data, uint64_t time)
-{
-       struct touchpad_accelerator *accel =
-               (struct touchpad_accelerator *) filter;
-       double accel_value; /* unitless factor */
-       struct device_float_coords accelerated;
-
-       accel_value = calculate_acceleration_factor(accel,
-                                                   unaccelerated,
-                                                   data,
-                                                   time);
-
-       accelerated.x = accel_value * unaccelerated->x;
-       accelerated.y = accel_value * unaccelerated->y;
-
-       return accelerated;
-}
-
 static struct normalized_coords
-accelerator_filter_post_normalized(struct motion_filter *filter,
-                                  const struct device_float_coords *unaccelerated,
-                                  void *data, uint64_t time)
+accelerator_filter_touchpad(struct motion_filter *filter,
+                           const struct device_float_coords *unaccelerated,
+                           void *data, uint64_t time)
 {
        struct touchpad_accelerator *accel =
                (struct touchpad_accelerator *) filter;
-       struct device_float_coords accelerated;
 
        /* Accelerate for device units, normalize afterwards */
-       accelerated = accelerator_filter_generic(filter,
-                                                unaccelerated,
-                                                data,
-                                                time);
+       double accel_factor = calculate_acceleration_factor(accel,
+                                                           unaccelerated,
+                                                           data,
+                                                           time);
+       const struct device_float_coords accelerated =  {
+               .x = unaccelerated->x * accel_factor,
+               .y = unaccelerated->y * accel_factor,
+       };
+
        return normalize_for_dpi(&accelerated, accel->dpi);
 }
 
@@ -315,7 +286,7 @@ touchpad_accel_profile_linear(struct motion_filter *filter,
 
 struct motion_filter_interface accelerator_interface_touchpad = {
        .type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
-       .filter = accelerator_filter_post_normalized,
+       .filter = accelerator_filter_touchpad,
        .filter_constant = touchpad_constant_filter,
        .restart = touchpad_accelerator_restart,
        .destroy = touchpad_accelerator_destroy,