Attachment 10106 Details for Bug 8583 – revised patch against master

[patch] revised patch against master

xorg-mouse-accel-against-git.patch (text/plain), 28.86 KB, created by Simon Thum on 2007-05-28 09:08:13 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Thum

Created: 2007-05-28 09:08:13 UTC

Size: 28.86 KB

patch

obsolete

>#
># Updated but not checked in:
>#   (will commit)
>#
>#	modified: dix/Makefile.am
>#	modified: dix/devices.c
>#	modified: dix/getevents.c
>#	new file: dix/ptrveloc.c
>#	modified: hw/xfree86/common/xf86Xinput.c
>#	modified: include/input.h
>#	modified: include/inputstr.h
>#	new file: include/ptrveloc.h
>#
>#
># Untracked files:
>#   (use "git add" to add to commit)
>#
>#	doc/SecurityPolicy.5
>#	doc/SecurityPolicy.man
>#	hw/xfree86/xf1bpp/maskbits.c
>#	hw/xfree86/xf1bpp/mfbbitblt.c
>#	hw/xfree86/xf1bpp/mfbbres.c
>#	hw/xfree86/xf1bpp/mfbbresd.c
>#	hw/xfree86/xf1bpp/mfbbstore.c
>#	hw/xfree86/xf1bpp/mfbclip.c
>#	hw/xfree86/xf1bpp/mfbcmap.c
>#	hw/xfree86/xf1bpp/mfbfillarc.c
>#	hw/xfree86/xf1bpp/mfbfillrct.c
>#	hw/xfree86/xf1bpp/mfbfillsp.c
>#	hw/xfree86/xf1bpp/mfbfont.c
>#	hw/xfree86/xf1bpp/mfbgc.c
>#	hw/xfree86/xf1bpp/mfbgetsp.c
>#	hw/xfree86/xf1bpp/mfbhrzvert.c
>#	hw/xfree86/xf1bpp/mfbimage.c
>#	hw/xfree86/xf1bpp/mfbline.c
>#	hw/xfree86/xf1bpp/mfbmisc.c
>#	hw/xfree86/xf1bpp/mfbpixmap.c
>#	hw/xfree86/xf1bpp/mfbpntwin.c
>#	hw/xfree86/xf1bpp/mfbpolypnt.c
>#	hw/xfree86/xf1bpp/mfbpushpxl.c
>#	hw/xfree86/xf1bpp/mfbscrclse.c
>#	hw/xfree86/xf1bpp/mfbscrinit.c
>#	hw/xfree86/xf1bpp/mfbsetsp.c
>#	hw/xfree86/xf1bpp/mfbwindow.c
>#	hw/xfree86/xf1bpp/mfbzerarc.c
>#	hw/xfree86/xorg.conf.example
>#	hw/xfree86/xorg.conf.example.pre
>#	ylwrap
>diff --git a/dix/Makefile.am b/dix/Makefile.am
>index a1f02c1..c9e56d4 100644
>--- a/dix/Makefile.am
>+++ b/dix/Makefile.am
>@@ -26,6 +26,7 @@ libdix_la_SOURCES = 	\
> 	pixmap.c	\
> 	privates.c	\
> 	property.c	\
>+	ptrveloc.c	\
> 	resource.c	\
> 	swaprep.c	\
> 	swapreq.c	\
>diff --git a/dix/devices.c b/dix/devices.c
>index e227617..bf1a00e 100644
>--- a/dix/devices.c
>+++ b/dix/devices.c
>@@ -62,6 +62,7 @@ #include "inputstr.h"
> #include "scrnintstr.h"
> #include "cursorstr.h"
> #include "dixstruct.h"
>+#include "ptrveloc.h"
> #include "site.h"
> #ifndef XKB_IN_SERVER
> #define	XKB_IN_SERVER
>@@ -466,6 +467,12 @@ #endif
>     }
> 
>     if (dev->valuator) {
>+        if(dev->valuator->accelData && 
>+           dev->valuator->AccelScheme == acceleratePointer){
>+            /* if more schemes are added this would need to be factored out */
>+            FreeVelocityData(dev->valuator->accelData);
>+            xfree(dev->valuator->accelData);
>+        }
>         /* Counterpart to 'biggest hack ever' in init. */
>         if (dev->valuator->motion &&
>             dev->valuator->GetMotionProc == GetMotionHistory)
>@@ -863,6 +870,8 @@ InitValuatorClassDeviceStruct(DeviceIntP
>     valc->lasty = 0;
>     valc->dxremaind = 0;
>     valc->dyremaind = 0;
>+    valc->AccelScheme = acceleratePointerPlain;  //simpler, needs no config
>+    valc->accelData = NULL;
>     dev->valuator = valc;
> 
>     /* biggest hack ever. */
>diff --git a/dix/getevents.c b/dix/getevents.c
>index 6969f78..3ef8c47 100644
>--- a/dix/getevents.c
>+++ b/dix/getevents.c
>@@ -60,6 +60,7 @@ #include "exevents.h"
> #include "exglobals.h"
> #include "extnsionst.h"
> 
>+#include <ptrveloc.h>
> 
> /* Maximum number of valuators, divided by six, rounded up, to get number
>  * of events. */
>@@ -197,80 +198,6 @@ #endif
> }
> 
> 
>-/* Originally a part of xf86PostMotionEvent; modifies valuators
>- * in-place. */
>-static void
>-acceleratePointer(DeviceIntPtr pDev, int first_valuator, int num_valuators,
>-                  int *valuators)
>-{
>-    float mult = 0.0;
>-    int dx = 0, dy = 0;
>-    int *px = NULL, *py = NULL;
>-
>-    if (!num_valuators || !valuators)
>-        return;
>-
>-    if (first_valuator == 0) {
>-        dx = valuators[0];
>-        px = &valuators[0];
>-    }
>-    if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
>-        dy = valuators[1 - first_valuator];
>-        py = &valuators[1 - first_valuator];
>-    }
>-
>-    if (!dx && !dy)
>-        return;
>-
>-    if (pDev->ptrfeed && pDev->ptrfeed->ctrl.num) {
>-        /* modeled from xf86Events.c */
>-        if (pDev->ptrfeed->ctrl.threshold) {
>-            if ((abs(dx) + abs(dy)) >= pDev->ptrfeed->ctrl.threshold) {
>-                pDev->valuator->dxremaind = ((float)dx *
>-                                             (float)(pDev->ptrfeed->ctrl.num)) /
>-                                             (float)(pDev->ptrfeed->ctrl.den) +
>-                                            pDev->valuator->dxremaind;
>-                if (px) {
>-                    *px = (int)pDev->valuator->dxremaind;
>-                    pDev->valuator->dxremaind = pDev->valuator->dxremaind -
>-                                                (float)(*px);
>-                }
>-
>-                pDev->valuator->dyremaind = ((float)dy *
>-                                             (float)(pDev->ptrfeed->ctrl.num)) /
>-                                             (float)(pDev->ptrfeed->ctrl.den) +
>-                                            pDev->valuator->dyremaind;
>-                if (py) {
>-                    *py = (int)pDev->valuator->dyremaind;
>-                    pDev->valuator->dyremaind = pDev->valuator->dyremaind -
>-                                                (float)(*py);
>-                }
>-            }
>-        }
>-        else {
>-            mult = pow((float)(dx * dx + dy * dy),
>-                       ((float)(pDev->ptrfeed->ctrl.num) /
>-                        (float)(pDev->ptrfeed->ctrl.den) - 1.0) /
>-                       2.0) / 2.0;
>-            if (dx) {
>-                pDev->valuator->dxremaind = mult * (float)dx +
>-                                            pDev->valuator->dxremaind;
>-                *px = (int)pDev->valuator->dxremaind;
>-                pDev->valuator->dxremaind = pDev->valuator->dxremaind -
>-                                            (float)(*px);
>-            }
>-            if (dy) {
>-                pDev->valuator->dyremaind = mult * (float)dy +
>-                                            pDev->valuator->dyremaind;
>-                *py = (int)pDev->valuator->dyremaind;
>-                pDev->valuator->dyremaind = pDev->valuator->dyremaind -
>-                                            (float)(*py);
>-            }
>-        }
>-    }
>-}
>-
>-
> /**
>  * Clip an axis to its bounds, which are declared in the call to
>  * InitValuatorAxisClassStruct.
>@@ -546,9 +473,13 @@ GetPointerEvents(xEvent *events, DeviceI
>         }
>     }
>     else {
>-        if (flags & POINTER_ACCELERATE)
>-            acceleratePointer(pDev, first_valuator, num_valuators,
>-                              valuators);
>+	if ((flags & POINTER_ACCELERATE) && pDev->valuator->AccelScheme){
>+            pDev->valuator->AccelScheme(pDev,
>+                                        first_valuator,
>+                                        num_valuators,
>+                                        valuators,
>+                                        ms);
>+	}
> 
>         if (pDev->coreEvents) {
>             if (first_valuator == 0 && num_valuators >= 1)
>diff --git a/dix/ptrveloc.c b/dix/ptrveloc.c
>new file mode 100644
>index 0000000..1d77ae0
>--- /dev/null
>+++ b/dix/ptrveloc.c
>@@ -0,0 +1,438 @@
>+
>+#ifdef HAVE_DIX_CONFIG_H
>+#include <dix-config.h>
>+#endif
>+
>+#include <math.h>
>+#include <ptrveloc.h>
>+#include <inputstr.h>
>+
>+
>+
>+/*****************************************************************************
>+ * Pointer ballistics 2006/2007 by Simon Thum (simon [dot] thum [at] gmx de)
>+ *
>+ * Serves 3 complementary functions:
>+ * 1) provide a sophisticated ballistic velocity estimate to improve
>+      the relation between velocity (of the device) and acceleration
>+ * 2) slightly soften mouse data when acceleration is applied
>+ * 3) decelerate by two means (constant and adaptive) if enabled
>+ *
>+ * Important concepts are the
>+ *
>+ * - Scheme
>+ *      which selects the basic algorithm (old/new (new is the stuff herein))
>+ * - Profile
>+ *      which (in case of the new scheme) selects the
>+ * - Function,
>+ *      which in turn selects an acceleration for any given velocity.
>+ *
>+ *  The Profile is currently a somewhat superfluous intermediary intended to
>+ *  cleanly perform old-style function selection (threshold =/!= 0)
>+ *  However, custom functions should be implemented as a profile.
>+ ****************************************************************************/
>+
>+/*
>+Init struct so it should match the average case
>+*/
>+void
>+InitVelocityData(MouseVelocityPtr s, float rdecay)
>+{
>+    s->lrm_time = 0;
>+    s->velocity  = 0;
>+    s->corr_mul = 10.0;      /* dots per 10 milisecond should be usable */
>+    s->const_acceleration = 1.0;   /* no acceleration/deceleration  */
>+    s->reset_time = 200;
>+    s->last_dx = 0;
>+    s->last_dy = 0;
>+    s->use_softening = 1;
>+    s->min_acceleration = 1.0; /* don't decelerate */
>+    s->use_coupling = 1;
>+    s->coupling = 0.2;
>+    s->profile = ClassicProfile;
>+    s->fading_lut_size = 0;
>+    s->fading_lut = NULL;
>+    s->profile_private = NULL;
>+    InitFadingLookup(s, rdecay, 40);
>+}
>+
>+/*
>+Runtime-adjust weighting decay and lut in sync
>+*/
>+void
>+InitFadingLookup(MouseVelocityPtr s, float rdecay, int lutsize)
>+{
>+    int x;
>+    float *newlut;
>+    float *oldlut;
>+
>+    if(lutsize > 0){
>+        newlut = xalloc (sizeof(float)* lutsize);
>+        if(!newlut)
>+            return;
>+        for(x = 0; x < lutsize; x++)
>+            newlut[x] = pow(0.5, ((float)x) * rdecay);
>+    }else{
>+        newlut = NULL;
>+    }
>+    oldlut = s->fading_lut;
>+    s->fading_lut = newlut;
>+    s->rdecay = rdecay;
>+    s->fading_lut_size = lutsize;
>+    if(oldlut != NULL)
>+        xfree(oldlut);
>+}
>+
>+/*
>+Clean up
>+param is a void* since the ptr in ValuatorClassRec is not typed either
>+*/
>+void
>+FreeVelocityData(void* p){
>+    MouseVelocityPtr s = (MouseVelocityPtr)p;
>+    s->fading_lut_size = 0;
>+    xfree(s->fading_lut);
>+    s->fading_lut = NULL;
>+    xfree(s->profile_private);
>+    s->profile_private = NULL;
>+}
>+
>+
>+/*
>+return the axis if mickey is insignificant and axis-aligned
>+*/
>+static inline short
>+GetAxis(int dx, int dy){
>+    if(dx == 0 || dy == 0){
>+        if(dx == 1 || dx == -1)
>+            return 1;
>+        if(dy == 1 || dy == -1)
>+            return 2;
>+        return -1;
>+    }else{
>+        return -1;
>+    }
>+}
>+
>+/*  Perform velocity approximation
>+    return true if non-visible state reset is suggested  */
>+short
>+ProcessVelocityData(MouseVelocityPtr s, int dx, int dy, int time)
>+{
>+    int diff = time - s->lrm_time;
>+    int cur_ax = GetAxis(dx, dy);
>+    int last_ax = GetAxis(s->last_dx, s->last_dy);
>+    float cvelocity, fade, div;
>+    short reset = (diff >= s->reset_time);
>+    if(cur_ax != last_ax && cur_ax != -1 && last_ax != -1 && !reset){
>+        /*DebugF("(dix) ProcessVelocityData diagonal correction %i %i",
>+                  cur_ax, last_ax);*/
>+        /* correct for the error induced when diagonal movements are
>+           reported as alternating axis mickeys */
>+        dx += s->last_dx;
>+        dy += s->last_dy;
>+        diff += s->last_diff;
>+        s->last_diff = time - s->lrm_time; /* no continuous add-up */
>+    }else{
>+        s->last_diff = diff;
>+    }
>+
>+    /* cvelocity is not a real velocity yet, more a motion delta. contant
>+    acceleration is multiplied here to make the velocity an on-screen velocity
>+    (px/t as opposed to some device velocity). This is expected to make
>+    multiple devices with widely varying ConstantDecelerations
>+    behave more similar */
>+    cvelocity = (float)sqrt(dx*dx + dy*dy) * s->const_acceleration;
>+
>+    s->lrm_time = time;
>+
>+    if (s->reset_time < 0 || diff < 0) {     /* disabled or timer overrun? */
>+        /* simply set velocity from current movement, no reset. */
>+        s->velocity = cvelocity;
>+        return 0;
>+    }
>+
>+    if (reset) {
>+        /* no movement for some time, suggest to reset nonvisible state */
>+        diff = s->reset_time;
>+        reset = TRUE;
>+    }
>+
>+    if (diff == 0)
>+        diff = 1; /* prevent div-by-zero, though it shouldn't happen anyway*/
>+
>+    /* translate velocity to dots/ms (somewhat untractable in integers,
>+       so we multiply by some per-device adjustable factor) */
>+    cvelocity = cvelocity * s->corr_mul / (float)diff;
>+
>+    /* short-circuit: when nv-reset the rest can be skipped */
>+    if(reset == TRUE){
>+        s->velocity = cvelocity;
>+        return TRUE;
>+    }
>+
>+    /* fading factor; crucial it matches definition in InitFadingLookup */
>+    if(diff < s->fading_lut_size)
>+        fade = s->fading_lut[diff];
>+    else
>+        fade = pow(0.5, ((float)diff) * s->rdecay);
>+
>+    s->velocity *= fade;    /* fade out old velocity info */
>+    s->velocity += cvelocity * (1.0f - fade);    /* and add up current */
>+
>+    /* perform coupling */
>+    if(s->use_coupling && cvelocity > 0 && fabs(s->velocity-cvelocity) > 1.0){
>+        div = fabs(cvelocity - s->velocity) / (s->velocity + cvelocity);
>+        if(div > s->coupling){    /* if divergence is too high...  */
>+            /* set current velocity as weighted to catch up quickly */
>+            s->velocity = cvelocity;
>+        }
>+    }
>+    /*DebugF("ProcessVelocityData acceleration guessing: vel=%.3f
>+    diff=%d curw=%.4f, fade=%.4f\n", s->velocity, diff, (1.0- fade), fade);*/
>+    return reset;
>+}
>+
>+
>+/* this flattens significant ( > 1) mickeys a little bit for more steady
>+   constant-velocity response
>+*/
>+static inline float
>+ApplySimpleSoftening(int od, int d)
>+{
>+    float res = d;
>+    if (d <= 1 && d >= -1)
>+        return res;
>+    if (d > od)
>+        res -= 0.5;
>+    else if (d < od)
>+        res += 0.5;
>+    return res;
>+}
>+
>+
>+void
>+ApplySofteningAndConstantDeceleration(
>+    MouseVelocityPtr s,
>+    int dx,
>+    int dy,
>+    float* fdx,
>+    float* fdy,
>+    short do_soften)
>+{
>+    if (do_soften && s->use_softening) {
>+	*fdx = ApplySimpleSoftening(s->last_dx, dx);
>+	*fdy = ApplySimpleSoftening(s->last_dy, dy);
>+    }
>+    else {
>+        *fdx = dx;
>+        *fdy = dy;
>+    }
>+
>+    *fdx *= s->const_acceleration;
>+    *fdy *= s->const_acceleration;
>+}
>+
>+
>+
>+/* acceleration function similar to classic accelerated/unaccelerated,
>+   introducing some transition range
>+*/
>+static float
>+SimpleAccelerationFunc(float velocity, float threshold, float acc)
>+{
>+    if(velocity < 1.0)
>+        return velocity;
>+    if (velocity <= threshold)
>+        return 1;
>+    velocity /= threshold;
>+    if (velocity >= acc)
>+        return acc;
>+    else
>+        return velocity;
>+
>+}
>+
>+/* Polynomial function similar previous one, but with f(1) = 1 */
>+static float
>+PolynomialAccelerationFunc(float velocity, float ignored, float acc)
>+{
>+   return pow(velocity, (acc - 1.0) * 0.5);
>+}
>+
>+/*
>+returns acceleration for velocity. The function is given the whole
>+MouseVelocityPtr as param to be able to adapt the function so it holds
>+property (4) as specified in doc (bug#8583)
>+The code below doesn't and needs only the velocity field.
>+*/
>+float
>+ClassicProfile(
>+    MouseVelocityPtr pVel,
>+    float threshold,
>+    float acc){
>+
>+    if (threshold) {
>+	return SimpleAccelerationFunc  (pVel->velocity,
>+				        threshold,
>+					acc);
>+    }
>+    else {
>+	return PolynomialAccelerationFunc(pVel->velocity,
>+	                                  0,
>+	                                  acc);
>+    }
>+}
>+
>+
>+
>+/*
>+ *  acceleration schemes
>+ */
>+
>+/*
>+Modifies valuators in-place.
>+This version employs a velocity approximation algorithm to
>+enable fine-grained acceleration profiles.
>+*/
>+void
>+acceleratePointer(DeviceIntPtr pDev, int first_valuator, int num_valuators,
>+                  int *valuators, int evtime)
>+{
>+    float mult = 0.0;
>+    int dx = 0, dy = 0;
>+    int *px = NULL, *py = NULL;
>+    MouseVelocityPtr velocitydata = (MouseVelocityPtr) pDev->valuator->accelData;
>+    float fdx, fdy; /* no need to init */
>+
>+    if (!num_valuators || !valuators || !velocitydata)
>+        return;
>+
>+    if (first_valuator == 0) {
>+        dx = valuators[0];
>+        px = &valuators[0];
>+    }
>+    if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
>+        dy = valuators[1 - first_valuator];
>+        py = &valuators[1 - first_valuator];
>+    }
>+
>+    if (dx || dy){
>+        /* reset nonvisible state? */
>+        if (ProcessVelocityData(velocitydata, dx , dy, evtime)) {
>+            /* set to center of pixel */
>+            pDev->valuator->dxremaind = pDev->valuator->dyremaind = 0.5f;
>+            /* prevent softening (somewhat quirky solution,
>+            as it depends on the algorithm) */
>+            velocitydata->last_dx = dx;
>+            velocitydata->last_dy = dy;
>+        }
>+
>+        if (pDev->ptrfeed && pDev->ptrfeed->ctrl.num) {
>+            /* invoke acceleration profile to determine acceleration */
>+            mult = velocitydata->profile(velocitydata,
>+                                pDev->ptrfeed->ctrl.threshold,
>+                                (float)(pDev->ptrfeed->ctrl.num) /
>+                                (float)(pDev->ptrfeed->ctrl.den));
>+
>+            /* enforce min_acceleration */
>+            if (mult < velocitydata->min_acceleration)
>+                mult = velocitydata->min_acceleration;
>+
>+            if(mult != 1.0 || velocitydata->const_acceleration != 1.0) {
>+                ApplySofteningAndConstantDeceleration(  velocitydata,
>+                                                        dx, dy,
>+                                                        &fdx, &fdy,
>+                                                        mult > 1.0);
>+                if (dx) {
>+                    pDev->valuator->dxremaind = mult * fdx + pDev->valuator->dxremaind;
>+                    *px = (int)pDev->valuator->dxremaind;
>+                    pDev->valuator->dxremaind = pDev->valuator->dxremaind - (float)*px;
>+                }
>+                if (dy) {
>+                    pDev->valuator->dyremaind = mult * fdy + pDev->valuator->dyremaind;
>+                    *py = (int)pDev->valuator->dyremaind;
>+                    pDev->valuator->dyremaind = pDev->valuator->dyremaind - (float)*py;
>+                }
>+            }
>+        }
>+    }
>+    /* remember last motion delta (for softening/slow movement treatment) */
>+    velocitydata->last_dx = dx;
>+    velocitydata->last_dy = dy;
>+}
>+
>+
>+
>+/* Originally a part of xf86PostMotionEvent; modifies valuators
>+ * in-place. */
>+void
>+acceleratePointerPlain(DeviceIntPtr pDev, int first_valuator, int num_valuators,
>+                        int *valuators, int ignore)
>+{
>+    float mult = 0.0;
>+    int dx = 0, dy = 0;
>+    int *px = NULL, *py = NULL;
>+
>+    if (!num_valuators || !valuators)
>+        return;
>+
>+    if (first_valuator == 0) {
>+        dx = valuators[0];
>+        px = &valuators[0];
>+    }
>+    if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
>+        dy = valuators[1 - first_valuator];
>+        py = &valuators[1 - first_valuator];
>+    }
>+
>+    if (!dx && !dy)
>+        return;
>+
>+    if (pDev->ptrfeed && pDev->ptrfeed->ctrl.num) {
>+        /* modeled from xf86Events.c */
>+        if (pDev->ptrfeed->ctrl.threshold) {
>+            if ((abs(dx) + abs(dy)) >= pDev->ptrfeed->ctrl.threshold) {
>+                pDev->valuator->dxremaind = ((float)dx *
>+                        (float)(pDev->ptrfeed->ctrl.num)) /
>+                        (float)(pDev->ptrfeed->ctrl.den) +
>+                        pDev->valuator->dxremaind;
>+                if (px) {
>+                    *px = (int)pDev->valuator->dxremaind;
>+                    pDev->valuator->dxremaind = pDev->valuator->dxremaind -
>+                            (float)(*px);
>+                }
>+
>+                pDev->valuator->dyremaind = ((float)dy *
>+                        (float)(pDev->ptrfeed->ctrl.num)) /
>+                        (float)(pDev->ptrfeed->ctrl.den) +
>+                        pDev->valuator->dyremaind;
>+                if (py) {
>+                    *py = (int)pDev->valuator->dyremaind;
>+                    pDev->valuator->dyremaind = pDev->valuator->dyremaind -
>+                            (float)(*py);
>+                }
>+            }
>+        }
>+        else {
>+            mult = pow((float)(dx * dx + dy * dy),
>+                        ((float)(pDev->ptrfeed->ctrl.num) /
>+                                (float)(pDev->ptrfeed->ctrl.den) - 1.0) /
>+                                2.0) / 2.0;
>+            if (dx) {
>+                pDev->valuator->dxremaind = mult * (float)dx +
>+                        pDev->valuator->dxremaind;
>+                *px = (int)pDev->valuator->dxremaind;
>+                pDev->valuator->dxremaind = pDev->valuator->dxremaind -
>+                        (float)(*px);
>+            }
>+            if (dy) {
>+                pDev->valuator->dyremaind = mult * (float)dy +
>+                        pDev->valuator->dyremaind;
>+                *py = (int)pDev->valuator->dyremaind;
>+                pDev->valuator->dyremaind = pDev->valuator->dyremaind -
>+                        (float)(*py);
>+            }
>+        }
>+    }
>+}
>diff --git a/hw/xfree86/common/xf86Xinput.c b/hw/xfree86/common/xf86Xinput.c
>index 2d0a376..30abb92 100644
>--- a/hw/xfree86/common/xf86Xinput.c
>+++ b/hw/xfree86/common/xf86Xinput.c
>@@ -90,12 +90,117 @@ #include "xf86_OSproc.h"	/* sigio stuff 
> 
> #include "mi.h"
> 
>+#include <ptrveloc.h>          /* dix pointer acceleration */
>+
>+
> #ifdef XFreeXDGA
> #include "dgaproc.h"
> #endif
> 
> xEvent *xf86Events = NULL;
> 
>+
>+/*
>+ * Eval config and init MouseVelocityData accordingly
>+ */
>+static MouseVelocityPtr
>+ProcessVelocityConfiguration(char* devname, pointer list){
>+    float tempf;
>+    MouseVelocityPtr s = xalloc(sizeof(MouseVelocityData));
>+    
>+    if(!s)
>+        return NULL;
>+
>+    /* TODO These settings should be reachable by API/xset  */
>+    tempf = xf86SetRealOption(list, "WeightingDecay", 15);
>+    xf86Msg(X_CONFIG, "%s: weighting decay %.1f ms\n", devname, tempf);
>+    if(tempf > 0)
>+        tempf = 1.0 / tempf;   /* set reciprocal if possible */
>+    else
>+        tempf = 10000;   /* else set fairly high */
>+
>+    InitVelocityData(s, tempf);
>+
>+    tempf = xf86SetIntOption(list, "ConstantDeceleration", 1);
>+    if(tempf > 1.0){
>+        xf86Msg(X_CONFIG, "%s: constant deceleration by %.1f\n", devname,
>+                tempf);
>+        s->const_acceleration = 1.0 / tempf;   /* set reciprocal deceleration
>+                                                  alias acceleration */
>+    }
>+
>+    tempf = xf86SetIntOption(list, "AdaptiveDeceleration", 1);
>+    if(tempf > 1.0){
>+        xf86Msg(X_CONFIG, "%s: adaptive deceleration by %.1f\n", devname,
>+                tempf);
>+        s->min_acceleration = 1.0 / tempf;   /* set minimum acceleration */
>+    }
>+
>+    tempf = xf86SetRealOption(list, "VelocityCoupling", 0.2);
>+    if(tempf > 0.0){
>+        xf86Msg(X_CONFIG, "%s: velocity coupling is %.1f%%\n", devname,
>+                tempf*100.0);
>+        s->coupling = tempf;
>+        s->use_coupling = 1;
>+    }else{
>+        s->use_coupling = 0;
>+        xf86Msg(X_CONFIG, "%s: disabled velocity coupling\n", devname);
>+    }
>+
>+    /*  Configure softening. If const deceleration is used, this is expected
>+     *  to provide better subpixel information so we enable
>+     *  Softening by default only if ConstantDeceleration is not used
>+     */
>+    s->use_softening = xf86SetBoolOption(list, "Softening",
>+                                         s->const_acceleration == 1.0);
>+
>+    s->reset_time = xf86SetIntOption(list, "VelocityReset", 200);
>+    
>+    tempf = xf86SetRealOption(list, "ExpectedRate", 0);
>+    if(tempf > 0){
>+        s->corr_mul = 1000.0 / tempf;
>+    }else{
>+        s->corr_mul = xf86SetRealOption(list, "VelocityScale", 10);
>+    }
>+
>+
>+    if (xf86SetBoolOption(list, "EstimateVelocity", 1) == 0) {
>+        s->reset_time = -1;    /* Disable */
>+        s->use_softening = 0;
>+        xf86Msg(X_CONFIG, "%s: Disabled velocity estimation\n", devname);
>+    }
>+    return s;
>+}
>+
>+/*
>+ * evalute local device options and move to dix valuator
>+ * Should be executed during init when valuator exists
>+ */
>+static void
>+ApplyExtendedValuatorSettings(LocalDevicePtr local){
>+    int scheme;
>+    void* schemedata;
>+    /* Apply improved acceleration; Better be a device-class final init proc
>+     * or whatever...
>+     */
>+    if(local && local->dev && local->dev->valuator){
>+        scheme = xf86SetIntOption(local->options, "AccelerationScheme", 1);
>+        switch(scheme){
>+            case 0:
>+                local->dev->valuator->AccelScheme = acceleratePointerPlain;
>+                break;
>+            case 1:
>+                schemedata = ProcessVelocityConfiguration(local->name,
>+                                                          local->options);
>+                if(schemedata){
>+                    local->dev->valuator->accelData = schemedata;
>+                    local->dev->valuator->AccelScheme = acceleratePointer;
>+                }
>+                break;
>+        }
>+    }
>+}
>+
> static Bool
> xf86SendDragEvents(DeviceIntPtr	device)
> {
>@@ -745,6 +850,10 @@ xf86InitValuatorAxisStruct(DeviceIntPtr 
> 
>     InitValuatorAxisStruct(dev, axnum, minval, maxval, resolution, min_res,
> 			   max_res);
>+    /* could as well be arguments to InitValuatorAxisStruct */
>+    if(axnum == 0)
>+        ApplyExtendedValuatorSettings(dev->public.devicePrivate);
>+
> }
> 
> /*
>diff --git a/include/input.h b/include/input.h
>index b399d3a..64616f8 100644
>--- a/include/input.h
>+++ b/include/input.h
>@@ -455,4 +455,26 @@ extern void DDXRingBell(
>     int pitch,
>     int duration);
> 
>+/* pointer acceleration handling */
>+typedef void (*PointerSchemeProc)(
>+    DeviceIntPtr /*pDev*/,
>+    int /*first_valuator*/,
>+    int /*num_valuators*/,
>+    int* /*valuators*/,
>+    int /*evtime*/);
>+
>+extern void acceleratePointer(
>+    DeviceIntPtr pDev,
>+    int first_valuator,
>+    int num_valuators,
>+    int *valuators,
>+    int evtime);
>+
>+extern void acceleratePointerPlain(
>+    DeviceIntPtr pDev,
>+    int first_valuator,
>+    int num_valuators,
>+    int *valuators,
>+    int ignore);
>+
> #endif /* INPUT_H */
>diff --git a/include/inputstr.h b/include/inputstr.h
>index 8f4e9b9..5987764 100644
>--- a/include/inputstr.h
>+++ b/include/inputstr.h
>@@ -158,7 +158,9 @@ typedef struct _ValuatorClassRec {
>     int			  *axisVal;
>     int                   lastx, lasty; /* last event recorded, not posted to
>                                          * client; see dix/devices.c */
>-    int                   dxremaind, dyremaind; /* for acceleration */
>+    float                 dxremaind, dyremaind; /* for acceleration */
>+    PointerSchemeProc     AccelScheme;
>+    void                  *accelData; /* at disposal of AccelScheme */
>     CARD8	 	  mode;
> } ValuatorClassRec, *ValuatorClassPtr;
> 
>diff --git a/include/ptrveloc.h b/include/ptrveloc.h
>new file mode 100644
>index 0000000..4eaf01d
>--- /dev/null
>+++ b/include/ptrveloc.h
>@@ -0,0 +1,81 @@
>+/*
>+*  2006/2007 by Simon Thum
>+*/
>+
>+#ifndef POINTERVELOCITY_H
>+#define POINTERVELOCITY_H
>+
>+struct _MouseVelocityData;
>+
>+/* return acceleration for velocity/threshold (profile) */
>+typedef float (*PointerAccelerationProfileFunc)
>+              (struct _MouseVelocityData* /*pVel*/,
>+               float /*threshold*/, float /*acc*/);
>+
>+/*  Contains all Data needed to implement mouse ballistics  */
>+
>+typedef struct _MouseVelocityData {
>+    /* time the last motion event was processed  */
>+    int     lrm_time;
>+    /* velocity as guessed by algo (read: weighted) */
>+    float   velocity;
>+    /* last motion delta and time-diff  */
>+    int     last_dx, last_dy, last_diff;
>+    /* lookup for fadeout values; 40 saves 99% of cases, bigger won't help
>+     * much, maximum sane size is reset_time+1, yielding 100% hit rate */
>+    float*   fading_lut;
>+    int fading_lut_size;
>+    /* config: multiply this into velocity; can be used to adujust behaviour,
>+     * about 2 to 25 is sensible */
>+    float   corr_mul;
>+    /* config: reciprocal decay ms are between full and half weight */
>+    float   rdecay;
>+    /* config: USED FOR CONSTANT DECELERATION ! but stored reciprocal
>+       for fmul is usually faster */
>+    float   const_acceleration;
>+    /* config: minimum acceleration; normally 1, set lower to enable subpixel
>+       precision */
>+    float   min_acceleration;
>+    /* config: reset non-visible state after this number of miliseconds
>+     * inactivity, -1 means disable velocity guessing */
>+    short   reset_time;
>+    /* config: use softening of mouse values */
>+    short   use_softening;
>+    /* config: use coupling of weighted and current velocity */
>+    short   use_coupling;
>+    /* config: maximum divergence to allow weighted velocity to be taken */
>+    float   coupling;
>+    /* selected acceleration profile */
>+    PointerAccelerationProfileFunc profile;
>+    /* extended data for profile impl, currently unused
>+       has to be allocated w/xalloc for correct cleanup */
>+    void*   profile_private;
>+} MouseVelocityData, *MouseVelocityPtr;
>+
>+
>+extern void
>+InitVelocityData(MouseVelocityPtr s, float rdecay);
>+
>+extern void
>+FreeVelocityData(void* s);
>+
>+extern void
>+InitFadingLookup(MouseVelocityPtr s, float rdecay, int lutsize);
>+
>+extern  short
>+ProcessVelocityData(MouseVelocityPtr s, int dx, int dy, int time);
>+
>+extern  void
>+ApplySofteningAndConstantDeceleration(
>+                            MouseVelocityPtr s,
>+                            int dx,
>+                            int dy,
>+                            float* fdx,
>+                            float* fdy,
>+                            short do_soften);
>+
>+extern float ClassicProfile(MouseVelocityPtr /*pVel*/,
>+                            float /*threshold*/, float /*max_acc*/);
>+
>+
>+#endif  /* POINTERVELOCITY_H */

Actions: View | Splinter Review

Attachments on bug 8583: 7319 | 7322 | 7492 | 7493 | 7772 | 7773 | 7858 | 7859 | 7969 | 7970 | 8201 | 9248 | 9389 | 9390 | 9565 | 10106 | 10107 | 10162 | 11617 | 11618 | 11756 | 13692 | 13693 | 13694 | 13695 | 13697 | 13771 | 14254 | 14255 | 14256 | 14257 | 14258 | 17544 | 17545 | 17626 | 17772 | 17773

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.