Merge lp:~mixxxdevelopers/mixxx/features_softtakeover into lp:~mixxxdevelopers/mixxx/trunk

[Sean M. Pappalardo]

This branch adds soft-takeover capabilities for MIDI controllers, both for simple XML mappings and MIDI scripting.

I'm requesting that this be included in time for Mixxx v1.9.0.

Note that the main goal was to add this for MIDI scripting. I did it for the XML mappings as well for completeness, but that part isn't totally useful until Mixxx can accept multiple <option>s for simple XML mappings. Adding that capability is beyond the scope of the feature itself since everything is hard-coded for a single <option>, and it would require modification of GUI classes as well, something I don't feel qualified to do, especially not with the hope of getting this merged in time for 1.9.0.

[Albert Santoni (gamegod)]

Hey Sean,

I'm going to give you a hard time because you're a developer. :)

Two questions:
1) How is this useful in its current incarnation if you can't have
multiple <options> blocks?

2) Why does this have to go in 1.9? None of the mappings are using it. ??

3) What are the SCS.3d changes you made? Should we cherry-pick those
changes and put them in trunk before everything else?

Thanks,
Albert

On Tue, Nov 16, 2010 at 4:58 PM, Sean M. Pappalardo
<email address hidden> wrote:
> Sean M. Pappalardo has proposed merging lp:~mixxxdevelopers/mixxx/features_softtakeover into lp:mixxx.
>
> Requested reviews:
>  Mixxx Development Team (mixxxdevelopers)
> Related bugs:
>  #555547 Add soft-takeover for MIDI controllers (XML and script)
>  https://bugs.launchpad.net/bugs/555547
>
>
> This branch adds soft-takeover capabilities for MIDI controllers, both for simple XML mappings and MIDI scripting.
>
> I'm requesting that this be included in time for Mixxx v1.9.0.
>
> Note that the main goal was to add this for MIDI scripting. I did it for the XML mappings as well for completeness, but that part isn't totally useful until Mixxx can accept multiple <option>s for simple XML mappings. Adding that capability is beyond the scope of the feature itself since everything is hard-coded for a single <option>, and it would require modification of GUI classes as well, something I don't feel qualified to do, especially not with the hope of getting this merged in time for 1.9.0.
> --
> https://code.launchpad.net/~mixxxdevelopers/mixxx/features_softtakeover/+merge/41027
> Your team Mixxx Development Team is requested to review the proposed merge of lp:~mixxxdevelopers/mixxx/features_softtakeover into lp:mixxx.
>
> === modified file 'mixxx/res/midi/Stanton-SCS3d-scripts.js'
> --- mixxx/res/midi/Stanton-SCS3d-scripts.js     2010-06-29 11:58:44 +0000
> +++ mixxx/res/midi/Stanton-SCS3d-scripts.js     2010-11-17 00:57:57 +0000
> @@ -64,7 +64,7 @@
>  StantonSCS3d.triggerS4 = 0xFF;
>
>  // Signals to (dis)connect by mode: Group, Key, Function name
> -StantonSCS3d.modeSignals = {"fx":[       ["[Flanger]", "lfoDepth", "StantonSCS3d.FXDepthLEDs"],
> +StantonSCS3d.modeSignals = {"fx":[    ["[Flanger]", "lfoDepth", "StantonSCS3d.FXDepthLEDs"],
>                                       ["[Flanger]", "lfoDelay", "StantonSCS3d.FXDelayLEDs"],
>                                       ["[Flanger]", "lfoPeriod", "StantonSCS3d.FXPeriodLEDs"],
>                                       ["CurrentChannel", "reverse", "StantonSCS3d.B11LED"],
> @@ -80,77 +80,77 @@
>                             "loop2":[ ["CurrentChannel", "pfl", "StantonSCS3d.B11LED"] ],
>                             "loop3":[ ["CurrentChannel", "pfl", "StantonSCS3d.B11LED"] ],
>                             "trig":[  ["CurrentChannel", "pfl", "StantonSCS3d.B11LED"],
> -                                                                         ["CurrentChannel", "hotcue_1_enabled", "StantonSCS3d.BsALED"],
> -                                                                         ["CurrentChannel", "hotcue_2_enabled", "StantonSCS3d.BsBLED"],
> -                                                                         ["CurrentChannel...

[Sean M. Pappalardo (pegasus-renegadetech)]

Dude, you didn't need to quote the whole diff. :P

> 1) How is this useful in its current incarnation if you can't have
> multiple <options> blocks?

The XML soft-takeover option is independent of the MIDI scripting soft-takeover, so it's 100% useable from script now. And any XML controls that currently use the <normal> option can be used with <soft-takeover> right now.

> 2) Why does this have to go in 1.9? None of the mappings are using it. ??

I guess the urgency was from the discussion of ReplayGain auto-adjusting things (which Vittorio might add as an option anyway since I still want it.) But I'm going to update the SCS.1m mapping to use soft-takeover, and the EKS Otus mappings will use it.

> 3) What are the SCS.3d changes you made?

Sorry, that's just whitespace, tabs-to-spaces. (Soft-takeover would be senseless on most touch-only devices.)

[JWC (jwc)]

This branch causes the following behavior:

If I turn a knob to one level (say 75%) and then whip it back (maybe to 25%) very fast, the knob stays at 75%. The effect is much more pronounced when I start at either 0% or 100% and whip it up or down. The problem is especially bad with knob controls, but I suppose that it's probably possible to have the same behavior occur for sliders if you move them fast enough.

[Sean M. Pappalardo (pegasus-renegadetech)]

> If I turn a knob to one level (say 75%) and then whip it back (maybe to 25%)
> very fast, the knob stays at 75%. The effect is much more pronounced when I
> start at either 0% or 100% and whip it up or down. The problem is especially
> bad with knob controls, but I suppose that it's probably possible to have the
> same behavior occur for sliders if you move them fast enough.

What's the refresh rate of your controller? That is, if you run Mixxx with --midiDebug and do the whipping, how great is the difference in successive values?

Is the control in question mapped via script? Which ControlObject is it working with that is exhibiting the problem?

(Of note, moving controls very quickly (with a slow controller refresh rate) is indistinguishable from the exact problem soft-takeover is trying to avoid. If you're The Flash, chances are you don't want soft-takeover.)

review: Needs Information

[Albert Santoni (gamegod)]

On Thu, Nov 18, 2010 at 12:57 AM, Sean M. Pappalardo
<email address hidden> wrote:
>
> Dude, you didn't need to quote the whole diff. :P
>
>> 1) How is this useful in its current incarnation if you can't have
>> multiple <options> blocks?
>
> The XML soft-takeover option is independent of the MIDI scripting soft-takeover, so it's 100% useable from script now. And any XML controls that currently use the <normal> option can be used with <soft-takeover> right now.

Then why is the XML soft-takeover code in this branch?

>
>> 2) Why does this have to go in 1.9? None of the mappings are using it. ??
>
> I guess the urgency was from the discussion of ReplayGain auto-adjusting things (which Vittorio might add as an option anyway since I still want it.) But I'm going to update the SCS.1m mapping to use soft-takeover, and the EKS Otus mappings will use it.
>

I hope you're not planning to do those for 1.9...

[Sean M. Pappalardo (pegasus-renegadetech)]

> Then why is the XML soft-takeover code in this branch?

The branch is called softTakeover. I added the XML and MIDI scripting implementations to this branch. If you're uneasy about using it before we have multiple <options> support, just don't tell anyone about the XML option. The version in MIDI script is fine to use now.

I was planning to update those mappings for a 1.9.x release, yes. It doesn't have to be 1.9.0 though.

[Sean M. Pappalardo (pegasus-renegadetech)]

If you don't feel comfortable merging this without the multiple <options> support, please tell me what I'd need to change and where in the GUI classes to support it. (I know what I need to do on the XML side.)

[JWC (jwc)]

Revision 2559 improves responsiveness with controls mapped in scripts by an enormous amount. I really have to whip the control very hard to cause the behavior again. I think it's very suitable for use now.

[Albert Santoni (gamegod)]

Hey Sean,

More comments:
- Can you save the value of QDateTime::currentDateTime() in an intermediate variable in your calculations? You call that function an awful lot.
- is it possible to roll the actual soft takeover logic out into a function? Just get it out of setValue() because it makes that function rather hard to read.

- I still don't know what we should do with the MIDI XML part of this. It's not bad, besides the duplication of the soft takeover logic, but I don't think there's a use case for it yet unless we have multiple XML <option> blocks.
- The swath of QMaps in MidiScriptEngine suggests they should maybe be rolled into a class at some point. (I don't expect you to fix this now, just giving you a heads up.)

Thanks,
Albert

review: Needs Fixing

[Albert Santoni (gamegod)]

Re: your comments on IRC:

[15:16] <Pegasus_RPG_> I'm just going to factor out all the soft-takeover stuff into a class
[15:16] <Pegasus_RPG_> then instantiate that in the MSE
[15:16] <Pegasus_RPG_> and optionally the MIDI device

Yeah, sounds good. :)

[Sean M. Pappalardo (pegasus-renegadetech)]

Ok, all factored out. Applicable code in MidiDevice and the MSE is very clean now.
- Now storing the value of QDateTime::currentDateTime() when possible to cut down on the number of calls to it
- For the XML part, go ahead and include it since it works fine and will be useful for controls that otherwise have a <normal/> option tag. (For the future, there is a blueprint for extending the system to accept multiple <option/>s. That limitation is a general one; not a fault or result of soft-takeover specifically, so it shouldn't have any bearing on this merge since this is still useful without it. (It would just be more useful with it.))

[RJ Skerry-Ryan (rryan)]

Hey Sean, looking good. Here are my questions/comments:

* In SoftTakeover::currentTimeMSecs()
  - The string hack isn't pretty but it's fine. QElapsedTimer is also a good solution to what you're doing here because you don't actually care about the time itself, just the delta time. Unfortunately it's only part of 4.7 onwards as well. QElapsedTimer isn't affected by e.g. the user changing the system time while Mixxx is running (QTime::elapsed is also affected by that problem).

* In SoftTakeover::ignore(MixxxControl, float, bool)
  - Where did the '3' values in threshold calculations come from?
  - maxValue, minValue contain invalid data for scaleFactor calculation if cpo is NULL
  - scaleFactor calculation is a little strange. Why is it fabs(maxvalue) - fabs(minvalue)? Seems like maxValue - minValue is probably what you want instead?
  - Also, a little odd that 128 is factored in here. As I understand it that's mostly only used for MIDI XML mappings. Should MIDI scripts that deal with controls directly also have the 128 factor?
  - Check for NULL value of 'temp' (otherwise a MIDI script or mapping can segfault Mixxx!)
  - How was 50 determined as the right time delay for ignoring? Please pull it out of the expression and make it a const variable set to 50 w/ a comment about it. Does it work with all latencies?

* In MixxxControl
  - the # of MIDI_OPT_SOFT_TAKEOVER is a mystery to me .. why are SCRIPT and SOFT_TAKEOVER 40 and 50? Could they just be 11 and 12, following the options coming before it?

Thanks!
RJ

review: Needs Fixing

[lp:~mixxxdevelopers/mixxx/features_softtakeover]

2563. By Sean M. Pappalardo on 2011-04-17

- Prevented calling ComputeValue on Soft-Takeover MIDI option (It's processed differently)
- Checked for NULL COs and set sensible defaults if they do happen to be NULL
- Fixed logic error in scale factor
- Moved subsequent-value-override-time into a const class variable

[Sean M. Pappalardo (pegasus-renegadetech)]

> * In SoftTakeover::currentTimeMSecs()
> - QElapsedTimer is also a good solution to what you're doing here because you don't actually
> care about the time itself, just the delta time.

True, but then I'd need to create and store pointers to QElapsedTimer objects for each MixxxControl that had soft-takeover enabled instead of just uints as currently. And run-time dynamic memory allocation is a no-no in a RT app, since enable/disable can happen at any time. (Granted QHash also dynamically allocates memory, but not anywhere near as much as another whole object.)

> * In SoftTakeover::ignore(MixxxControl, float, bool)
> - Where did the '3' values in threshold calculations come from?

Experimentation. 3/128 units away from the current is enough to catch fast non-sequential moves but not cause an audially noticeable jump.

> - maxValue, minValue contain invalid data for scaleFactor calculation if cpo
> is NULL

I know, but there are no sensible defaults since CO ranges can vary widely. Just hurry up with Control 2.0. ;) For now, I've set max to something really high and min to 0 so that the if(diff>threshold) always fails, effectively disabling soft-takeover for that pass.

> - scaleFactor calculation is a little strange. Why is it fabs(maxvalue) -
> fabs(minvalue)? Seems like maxValue - minValue is probably what you want
> instead?

Hmm, you're right. Logic error I guess. Fixed.

> - Also, a little odd that 128 is factored in here. As I understand it that's
> mostly only used for MIDI XML mappings. Should MIDI scripts that deal with
> controls directly also have the 128 factor?

No, no. I just did that for consistency. See above. We could just as easily do threshold=difference*(3/128). I've changed the code to do this so it's clear.

> - Check for NULL value of 'temp' (otherwise a MIDI script or mapping can
> segfault Mixxx!)

Done.

> - How was 50 determined as the right time delay for ignoring?

Experimentally. Unless there exists a controller with a really slow control sampling rate, it's just enough to catch wide swings in a short amount of time without defeating the purpose of soft-takeover. Tested and approved by "fast fingers" Joe (JJWC.) :)

> Please pull it
> out of the expression and make it a const variable set to 50 w/ a comment
> about it. Does it work with all latencies?

Done. I would expect that it works with all latencies since MIDI data input speed is not tied to latency. It tests good for me at 1ms and 42ms anyway.

> * In MixxxControl
> - the # of MIDI_OPT_SOFT_TAKEOVER is a mystery to me .. why are SCRIPT and
> SOFT_TAKEOVER 40 and 50? Could they just be 11 and 12, following the options
> coming before it?

Sure they could but I spaced them out since they're conceptually different from the others in that they don't directly modify values the same way rot64, jog, etc. do, leaving room for additional direct-modify options.

[Sean M. Pappalardo (pegasus-renegadetech)]

review: Abstain

[RJ Skerry-Ryan (rryan)]

Looks good, thanks Sean

Minor nitpick in midiscriptengine.cpp

 if(cot != NULL) {
- cot->slotSet(newValue);
+ if (!m_st.ignore(group,name,newValue)) cot->slotSet(newValue);
     }

You should probably fold the two if statements into one.

Also one line if statements, while they are concise are often problematic 1) because it's easy to overlook that it's even there and 2) because there are no braces to protect against someone adding another statement mistakenly. I have a slight preference to not have one-line or brace-less if's anywhere in Mixxx if possible since they can be a source of bugs.

Go ahead and merge to trunk -- we haven't been strict at all about the feature freeze this time around and this only affects controllers with it explicitly enabled so I don't see a problem.

thanks again,
rj

review: Approve

[lp:~mixxxdevelopers/mixxx/features_softtakeover]

2564. By Sean M. Pappalardo on 2011-04-28

Condensed IF statement per RJ

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2011-04-26 02:07:24 +0000
+++ mixxx/build/depends.py	2011-04-28 21:01:18 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 
 import os
 import util
@@ -401,6 +402,7 @@
                    "midi/midioptiondelegate.cpp",
                    "midi/midimessage.cpp",
                    "midi/midiledhandler.cpp",
+                   "softtakeover.cpp",
 
                    "main.cpp",
                    "controlgroupdelegate.cpp",

=== modified file 'mixxx/src/midi/mididevice.cpp'
--- mixxx/src/midi/mididevice.cpp	2011-03-22 16:24:04 +0000
+++ mixxx/src/midi/mididevice.cpp	2011-04-28 21:01:18 +0000
@@ -229,11 +229,13 @@
     //qDebug() << "MidiDevice: " << mixxxControl.getControlObjectGroup() << mixxxControl.getControlObjectValue();
 
     ConfigKey configKey(mixxxControl.getControlObjectGroup(), mixxxControl.getControlObjectValue());
+    
+    MidiOption currMidiOption = mixxxControl.getMidiOption();
 
 #ifdef __MIDISCRIPT__
     // Custom MixxxScript (QtScript) handler
 
-    if (mixxxControl.getMidiOption() == MIDI_OPT_SCRIPT) {
+    if (currMidiOption == MIDI_OPT_SCRIPT) {
         // qDebug() << "MidiDevice: Calling script function" << configKey.item << "with"
         //          << (int)channel << (int)control <<  (int)value << (int)status;
 
@@ -253,24 +255,26 @@
 
     if (p) //Only pass values on to valid ControlObjects.
     {
-        double newValue;
-       
+        double currMixxxControlValue = p->GetMidiValue();
+
+        double newValue = value;
+
         // compute LSB and MSB for pitch bend messages
         if (status == MIDI_STATUS_PITCH_BEND) {
             unsigned int ivalue;
             ivalue = (value << 7) + control;
 
-            newValue = m_pMidiMapping->ComputeValue(mixxxControl.getMidiOption(), p->GetMidiValue(), ivalue);
+            newValue = m_pMidiMapping->ComputeValue(currMidiOption, currMixxxControlValue, ivalue);
 
             // normalize our value to 0-127
             newValue = (newValue / 0x3FFF) * 0x7F;
-        } else {
-            newValue = m_pMidiMapping->ComputeValue(mixxxControl.getMidiOption(), p->GetMidiValue(), value);
+        } else if (currMidiOption != MIDI_OPT_SOFT_TAKEOVER) {
+            newValue = m_pMidiMapping->ComputeValue(currMidiOption, currMixxxControlValue, value);
         }
 
         // ControlPushButton ControlObjects only accept NOTE_ON, so if the midi
         // mapping is <button> we override the Midi 'status' appropriately.
-        switch (mixxxControl.getMidiOption()) {
+        switch (currMidiOption) {
             case MIDI_OPT_BUTTON:
             case MIDI_OPT_SWITCH: status = MIDI_STATUS_NOTE_ON; break; // Buttons and Switches are
                                                                        // treated the same, except
@@ -278,7 +282,13 @@
                                                                        // computed differently.
             default: break;
         }
-
+        
+        // Soft-takeover is processed in addition to any other options
+        if (currMidiOption == MIDI_OPT_SOFT_TAKEOVER) {
+            m_st.enable(mixxxControl);  // This is the only place to enable it if it isn't already.
+            if (m_st.ignore(mixxxControl,newValue,true)) return;
+        }
+        
         ControlObject::sync();
 
         //Super dangerous cast here... Should be fine once MidiCategory is replaced with MidiStatusByte permanently.
@@ -294,7 +304,7 @@
     QMutexLocker locker(&m_mutex); //Lots of returns in this function. Keeps things simple.
 
     QString message = m_strDeviceName+": [";
-    for(int i=0; i<length; i++) {
+    for(uint i=0; i<length; i++) {
         message += QString("%1%2")
                     .arg(data[i], 2, 16, QChar('0')).toUpper()
                     .arg((i<(length-1))?' ':']');

=== modified file 'mixxx/src/midi/mididevice.h'
--- mixxx/src/midi/mididevice.h	2010-11-29 21:23:11 +0000
+++ mixxx/src/midi/mididevice.h	2011-04-28 21:01:18 +0000
@@ -33,6 +33,7 @@
 
 #include <QtCore>
 #include "midimessage.h"
+#include "softtakeover.h"
 
 //Forward declarations
 class MidiMapping;
@@ -106,6 +107,7 @@
             a race condition when a MIDI message is received and looked up in the MidiMapping while
             the MidiMapping is being modified (and is already locked).  */
         bool m_bReceiveInhibit;
+        SoftTakeover m_st;
 };
 
 #endif

=== modified file 'mixxx/src/midi/midimapping.cpp'
--- mixxx/src/midi/midimapping.cpp	2011-04-10 20:27:59 +0000
+++ mixxx/src/midi/midimapping.cpp	2011-04-28 21:01:18 +0000
@@ -705,7 +705,11 @@
  */
 void MidiMapping::savePreset(QString path) {
     qDebug() << "Writing MIDI preset file" << path;
+<<<<<<< TREE
     QMutexLocker locker(&m_mappingLock);
+=======
+    QMutexLocker lock(&m_mappingLock);
+>>>>>>> MERGE-SOURCE
     QFile output(path);
     if (!output.open(QIODevice::WriteOnly | QIODevice::Truncate)) return;
     QTextStream outputstream(&output);

=== modified file 'mixxx/src/midi/midioptiondelegate.cpp'
--- mixxx/src/midi/midioptiondelegate.cpp	2010-11-15 18:04:41 +0000
+++ mixxx/src/midi/midioptiondelegate.cpp	2011-04-28 21:01:18 +0000
@@ -21,6 +21,7 @@
 #define MIDI_OPT_STRING_HERC_JOG    "HercJog"    // Generic hercules wierd range correction
 #define MIDI_OPT_STRING_SPREAD64    "Spread64"   // Accelerated difference from 64
 #define MIDI_OPT_STRING_SELECTKNOB  "SelectKnob" // Relative knob which can be turned forever and outputs a signed value.
+#define MIDI_OPT_STRING_SOFT_TAKEOVER   "SoftTakeover"  // Prevents sudden changes when hardware & software MixxxControl value differ
 #define MIDI_OPT_STRING_SCRIPT      "Script"     // Maps a MIDI control to a custom MixxxScript function
 
 MidiOptionDelegate::MidiOptionDelegate(QObject *parent)
@@ -50,7 +51,8 @@
            case MIDI_OPT_HERC_JOG: text = MIDI_OPT_STRING_HERC_JOG; break;
            case MIDI_OPT_SPREAD64: text = MIDI_OPT_STRING_SPREAD64; break;
            case MIDI_OPT_SELECTKNOB: text = MIDI_OPT_STRING_SELECTKNOB; break;
-           case MIDI_OPT_SCRIPT: text = MIDI_OPT_STRING_SCRIPT; break;      
+           case MIDI_OPT_SOFT_TAKEOVER: text = MIDI_OPT_STRING_SOFT_TAKEOVER; break;
+           case MIDI_OPT_SCRIPT: text = MIDI_OPT_STRING_SCRIPT; break;
            default: text = QString("%1").arg(midioption); break;                           
         }
 
@@ -77,6 +79,7 @@
     editor->addItem(MIDI_OPT_STRING_HERC_JOG);
     editor->addItem(MIDI_OPT_STRING_SPREAD64);
     editor->addItem(MIDI_OPT_STRING_SELECTKNOB);
+    editor->addItem(MIDI_OPT_STRING_SOFT_TAKEOVER);
     editor->addItem(MIDI_OPT_STRING_SCRIPT);
 
     return editor;
@@ -102,7 +105,8 @@
         case MIDI_OPT_HERC_JOG:     comboIdx = 8; break;
         case MIDI_OPT_SPREAD64:     comboIdx = 9; break;
         case MIDI_OPT_SELECTKNOB:   comboIdx = 10; break;
-        case MIDI_OPT_SCRIPT:       comboIdx = 11; break;      
+        case MIDI_OPT_SOFT_TAKEOVER:comboIdx = 11; break;      
+        case MIDI_OPT_SCRIPT:       comboIdx = 12; break;
         default: comboIdx = 0; break;      
     }
     comboBox->setCurrentIndex(comboIdx);
@@ -116,6 +120,7 @@
     //comboBox->interpretText();
     //Get the text from the combobox and turn it into a MidiMessage integer.
     QString text = comboBox->currentText();
+    // Sigh, it sucks that we can't switch() on a string...
     if (text == MIDI_OPT_STRING_NORMAL) //These come from the MidiOption enum (mixxxcontrol.h)
         midioption = MIDI_OPT_NORMAL;
     else if (text == MIDI_OPT_STRING_INVERT)
@@ -138,8 +143,10 @@
         midioption = MIDI_OPT_SPREAD64;
     else if (text == MIDI_OPT_STRING_SELECTKNOB)
         midioption = MIDI_OPT_SELECTKNOB;
+    else if (text == MIDI_OPT_STRING_SOFT_TAKEOVER)
+        midioption = MIDI_OPT_SOFT_TAKEOVER;
     else if (text == MIDI_OPT_STRING_SCRIPT)
-        midioption = MIDI_OPT_SCRIPT;                                                                
+        midioption = MIDI_OPT_SCRIPT;
     model->setData(index, midioption, Qt::EditRole);
 }
 

=== modified file 'mixxx/src/midi/midiscriptengine.cpp'
--- mixxx/src/midi/midiscriptengine.cpp	2011-04-16 20:56:59 +0000
+++ mixxx/src/midi/midiscriptengine.cpp	2011-04-28 21:01:18 +0000
@@ -717,7 +717,7 @@
 
     ControlObjectThread *cot = getControlObjectThread(group, name);
 
-    if(cot != NULL) {
+    if(cot != NULL && !m_st.ignore(group,name,newValue)) {
         cot->slotSet(newValue);
     }
 
@@ -1262,3 +1262,15 @@
 
     m_ramp[deck] = true;    // Activate the ramping in scratchProcess()
 }
+
+/*  -------- ------------------------------------------------------
+    Purpose: [En/dis]ables soft-takeover status for a particular MixxxControl
+    Input:   MixxxControl group and key values,
+                whether to set the soft-takeover status or not
+    Output:  -
+    -------- ------------------------------------------------------ */
+void MidiScriptEngine::softTakeover(QString group, QString name, bool set) {
+    MixxxControl mc = MixxxControl(group,name);
+    if (set) m_st.enable(mc);
+    else m_st.disable(mc);
+}
\ No newline at end of file

=== modified file 'mixxx/src/midi/midiscriptengine.h'
--- mixxx/src/midi/midiscriptengine.h	2011-03-12 19:43:59 +0000
+++ mixxx/src/midi/midiscriptengine.h	2011-04-28 21:01:18 +0000
@@ -23,6 +23,8 @@
 #include "configobject.h"
 #include "midimessage.h"
 #include "pitchfilter.h"
+#include "softtakeover.h"
+
 class MidiDevice;
 
 //Forward declaration(s)
@@ -62,6 +64,7 @@
     Q_INVOKABLE void scratchEnable(int deck, int intervalsPerRev, float rpm, float alpha, float beta);
     Q_INVOKABLE void scratchTick(int deck, int interval);
     Q_INVOKABLE void scratchDisable(int deck);
+    Q_INVOKABLE void softTakeover(QString group, QString name, bool set);
 
   public slots:
     void slotValueChanged(double value);
@@ -119,6 +122,7 @@
     QMutex m_scriptEngineLock;
     QHash<ConfigKey, ControlObjectThread*> m_controlCache;
     QHash<int, QPair<QString, bool> > m_timers;
+    SoftTakeover m_st;
 
     // Scratching functions & variables
     void scratchProcess(int timerId);

=== modified file 'mixxx/src/mixxxcontrol.cpp'
--- mixxx/src/mixxxcontrol.cpp	2010-11-15 18:04:41 +0000
+++ mixxx/src/mixxxcontrol.cpp	2011-04-28 21:01:18 +0000
@@ -35,7 +35,7 @@
         strMidiOption = "normal";
     }
 
-    if (strMidiOption == "normal")
+    if (strMidiOption == "normal")  // can't switch() on a string
         m_midiOption = MIDI_OPT_NORMAL;
     else if (strMidiOption == "invert")
         m_midiOption = MIDI_OPT_INVERT;
@@ -57,6 +57,8 @@
         m_midiOption = MIDI_OPT_SPREAD64;
     else if (strMidiOption == "selectknob")
         m_midiOption = MIDI_OPT_SELECTKNOB;
+    else if (strMidiOption == "soft-takeover")
+        m_midiOption = MIDI_OPT_SOFT_TAKEOVER;
     else if (strMidiOption == "script-binding")
         m_midiOption = MIDI_OPT_SCRIPT;
     else {
@@ -114,7 +116,7 @@
     QDomElement optionsNode = nodeMaker.createElement("options");
     QString strMidiOption;
     int iMidiOption = this->getMidiOption();
-    if (iMidiOption == MIDI_OPT_NORMAL)
+    if (iMidiOption == MIDI_OPT_NORMAL) // can't switch() on a string
         strMidiOption = "normal";
     else if (iMidiOption == MIDI_OPT_INVERT)
         strMidiOption = "invert";
@@ -136,6 +138,8 @@
         strMidiOption = "spread64";
     else if (iMidiOption == MIDI_OPT_SELECTKNOB)
         strMidiOption = "selectknob";
+    else if (iMidiOption == MIDI_OPT_SOFT_TAKEOVER)
+        strMidiOption = "soft-takeover";
     else if (iMidiOption == MIDI_OPT_SCRIPT)
         strMidiOption = "script-binding";
     else {

=== modified file 'mixxx/src/mixxxcontrol.h'
--- mixxx/src/mixxxcontrol.h	2010-11-15 18:04:41 +0000
+++ mixxx/src/mixxxcontrol.h	2011-04-28 21:01:18 +0000
@@ -16,6 +16,8 @@
     MIDI_OPT_HERC_JOG         = 8, // Generic hercules wierd range correction
     MIDI_OPT_SPREAD64         = 9, // Accelerated difference from 64
     MIDI_OPT_SELECTKNOB       = 10,// Relative knob which can be turned forever and outputs a signed value.
+
+    MIDI_OPT_SOFT_TAKEOVER    = 40,// Prevents sudden changes when hardware position differs from software value
     
     MIDI_OPT_SCRIPT           = 50,// Maps a MIDI control to a custom MixxxScript function
 } MidiOption;

=== added file 'mixxx/src/softtakeover.cpp'
--- mixxx/src/softtakeover.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/softtakeover.cpp	2011-04-28 21:01:18 +0000
@@ -0,0 +1,115 @@
+/***************************************************************************
+                          softtakeover.cpp  -  description
+                          ----------------
+    begin                : Sat Mar 26 2011
+    copyright            : (C) 2011 by Sean M. Pappalardo
+    email                : [e-mail]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "softtakeover.h"
+#include <math.h>  // for fabs()
+#include <qdatetime.h>
+
+// HACK: remove this after Control 2.0 is here
+#include "controlpotmeter.h"
+
+// qint64 currentTimeMsecs() {
+uint SoftTakeover::currentTimeMsecs() {
+    QDateTime currDT = QDateTime::currentDateTime();
+
+    // toMSecsSinceEpoch() is preferred since it's only one QDateTime call but
+    //  it requires Qt 4.7. Use it instead when something more substantial
+    //  elsewhere in Mixxx also requires Qt 4.7.
+    //qint64 t = dt.toMSecsSinceEpoch();  // Requires Qt 4.7
+    uint t = currDT.toTime_t()*1000+currDT.toString("zzz").toUInt();
+    return t;
+}
+
+// For legacy Controls
+void SoftTakeover::enable(QString group, QString name) {
+    MixxxControl mixxxControl = MixxxControl(group,name);
+    enable(mixxxControl);
+}
+
+void SoftTakeover::enable(MixxxControl control) {
+    if (!m_times.contains(control)) m_times.insert(control,currentTimeMsecs());
+}
+
+// For legacy Controls
+void SoftTakeover::disable(QString group, QString name) {
+    MixxxControl mixxxControl = MixxxControl(group,name);
+    disable(mixxxControl);
+}
+
+void SoftTakeover::disable(MixxxControl control) {
+    m_times.remove(control);
+}
+
+// For legacy Controls
+bool SoftTakeover::ignore(QString group, QString name, float newValue) {
+    MixxxControl mixxxControl = MixxxControl(group,name);
+    return ignore(mixxxControl,newValue);
+}
+
+bool SoftTakeover::ignore(MixxxControl mc, float newValue, bool midiVal) {
+    bool ignore = false;
+    QString message;
+    if (m_times.contains(mc)) {
+        // We only want to ignore the MIDI controller when all of the following are true:
+        //  - its new value is far away from the MixxxControl
+        //  - it's been awhile since the last MIDI message for this control affected it
+        
+        // 3/128 units away from the current is enough to catch fast non-sequential moves
+        //  but not cause an audially noticeable jump.
+        float threshold = 3;
+        
+        ControlObject* temp = ControlObject::getControl(
+            ConfigKey(mc.getControlObjectGroup(), mc.getControlObjectValue()));
+
+        if (temp == NULL) return ignore;
+        
+        if (!midiVal) {
+            // These defaults will effectively disable soft-takeover for this pass
+            //  (causing the control to jump to the new value regardless)
+            //  if there's a problem with the below CO being NULL
+            double maxValue=10000000;   // Anything, just higher than any CO can go
+            double minValue=0;
+            
+            // HACK until we have Control 2.0. It can't come soon enough...
+            ControlPotmeter* cpo = dynamic_cast<ControlPotmeter*>(temp);    // for getMax/getMin
+            if (cpo != NULL) {
+                maxValue = cpo->getMax();
+                minValue = cpo->getMin();
+            }
+            // End hack
+            
+            double scaleFactor = maxValue-minValue;
+            threshold = scaleFactor*(threshold/128);
+        }
+        
+        double oldValue;
+        if (midiVal) oldValue = temp->GetMidiValue();
+        else oldValue = temp->get();
+        double difference = oldValue - newValue;
+        
+        uint currentTime = currentTimeMsecs();
+        if (fabs(difference)>threshold
+            && (currentTime - m_times.value(mc)) > SUBSEQUENT_VALUE_OVERRIDE_TIME) {
+            ignore = true;
+        }
+        if (!ignore) {
+            //  Update the time only if the value is not ignored
+            m_times.insert(mc,currentTime); // Replaces any previous value for this MixxxControl
+        }
+    }
+    return ignore;
+}

=== added file 'mixxx/src/softtakeover.h'
--- mixxx/src/softtakeover.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/softtakeover.h	2011-04-28 21:01:18 +0000
@@ -0,0 +1,50 @@
+/***************************************************************************
+                           softtakeover.h  -  description
+                           --------------
+    begin                : Thu Mar 17 2011
+    copyright            : (C) 2011 by Sean M. Pappalardo
+    email                : [e-mail]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#ifndef SOFTTAKEOVER_H
+#define SOFTTAKEOVER_H
+
+#include "mixxxcontrol.h"
+
+class SoftTakeover {
+
+    public:
+        /** Enable soft-takeover for the given Control
+            It's okay to call this on a Control that's already enabled. */
+        void enable(MixxxControl control);
+        void enable(QString group, QString name);
+        /** Disable soft-takeover for the given Control */
+        void disable(MixxxControl control);
+        void disable(QString group, QString name);
+        /** Check to see if the new value for the Control should be ignored */
+        bool ignore(MixxxControl control, float newValue, bool midiVal = false);
+        /** For legacy Controls */
+        bool ignore(QString group, QString name, float newValue);
+    
+    private:
+        /** If a new value is received within this amount of time,
+            jump to it regardless. This allows quickly whipping controls to work
+            while retaining the benefits of soft-takeover for slower movements.
+            
+            Setting this too high will defeat the purpose of soft-takeover.*/        
+        static const uint SUBSEQUENT_VALUE_OVERRIDE_TIME = 50;   // Milliseconds
+        //qint64 currentTimeMsecs();
+        //QHash<MixxxControl,qint64> m_times;
+        uint currentTimeMsecs();
+        QHash<MixxxControl,uint> m_times;
+};
+
+#endif
\ No newline at end of file