Merge lp:~mixxxdevelopers/mixxx/atomic-co into lp:~mixxxdevelopers/mixxx/trunk

[Daniel Schürmann]

This is the first transition of the control object part of Mixxx for a proof of concept as described in http://mixxx.org/wiki/doku.php/revamped_control_system

The core change was made in http://bazaar.launchpad.net/~mixxxdevelopers/mixxx/atomic-co/view/head:/mixxx/src/controlobjectbase.h

The class ControlObjectValue provides a lock-free thread save access to the value of the control object. Relying on this, it was possible to remove the mirrored values in the control object proxies and all the ugly code for syncing it. The new concept should provide an instant access to the control object values without possible delays of sync tasks or overloaded queues.

I have tried to keep the interface of the control objects untouched. Defining a suitable interface, and allowing different value types will be issued in the next transition, when this one is approved.

When reviewing please, give a particularly critical look to ControlObjectValue for verify that it provides such an atomic access.

[lp:~mixxxdevelopers/mixxx/atomic-co]

3350. By Daniel Schürmann on 2013-03-31

removed volatile qualifier for being QString compatible

3351. By Daniel Schürmann on 2013-03-31

merged from lp:mixxx

3352. By Daniel Schürmann on 2013-05-01

merged from lp:mixxx

[RJ Skerry-Ryan (rryan)]

Sorry for taking so long to get you feedback :( better late than never?

I've skimmed the whole thing once but for now will just comment on controlobjectbase.h:

* static const int cReaderSlotCnt
  - Should not be static.. if multiple object files include controlobjectbase.h then we will get duplicate symbols during linking. This builds fine now because only controlobject.o includes it. You could just leave it as a const int.

* sizeof(T) <= sizeof(void*) is not enough to determine atomicity -- for example, if the pointer to a value is not memory-aligned then that breaks atomicity guarantees. I think to be sure we need to use a compiler directive in the ATOMIC=true template to request m_value is aligned.

* Need comments on all methods declarations in controlobjectbase.h. This is such a crucial file it needs plenty of documentation for future developers :).

* ControlObjectRingValue::tryGet()
  - why return an int when it's functionally a bool (i.e. was it successful)
  - bool originalSlots = m_readerSlots.fetchAndAddAcquire(-1);
  Should instead be:
    bool originalSlots = m_readerSlots.fetchAndAddAcquire(-1) <= 0;

The reason is this: m_readerSlots can go negative if too many concurrent reads occur simultaneously. It can even go negative if a write is happening and two reads happen right after the write has swapped m_readerSlots with the value 0 (the second read will see -1). So to detect whether a read should be successful, you should check if the value is <= 0.

  - Why is cReaderSlotCnt the number of concurrent readers allowed also the size of the ring buffer? I can't think of a reason why those 2 values need to be the same.
  - How did you choose 7?

* ControlObjectValue::getValue
  - Can you use ARRAYSIZE on m_ring instead of hard-coding cReaderSlotCnt+1 ? It should be compile-time.
  - When getValue() fails to read a slot, it goes backward one. This means we sacrifice consistency for speed. We need to make sure people understand this is a trade-off that is part of the control system. Under high load, the control system will possibly serve a stale result when you get().

[lp:~mixxxdevelopers/mixxx/atomic-co]

3353. By Daniel Schürmann on 2013-05-11

merged from lp:mixxx

3354. By Daniel Schürmann on 2013-05-11

removed static keyword

3355. By Daniel Schürmann on 2013-05-11

reinterpret_cast to QAtomicPointer

3356. By Daniel Schürmann on 2013-05-11

added comments and removed unused template class

3357. By Daniel Schürmann on 2013-05-11

fixed ControlObjectRingValue::tryGet()

3358. By Daniel Schürmann on 2013-05-12

added more comments

3359. By Daniel Schürmann on 2013-05-12

cRingSize added + an assertion to check for valid values

[Daniel Schürmann (daschuer)]

Thank you for review!

> * static const int cReaderSlotCnt
OK

> * sizeof(T) <= sizeof(void*) is not enough to determine atomicity
OK, It should be save in any case, if we cast to an QAtomicPointer container
But that looks really ugly. But better ugly than a failure!

> * Need comments
OK

> * ControlObjectRingValue::tryGet()
Fixed.

> - Why is cReaderSlotCnt the number of concurrent readers allowed also the size of the ring buffer? I can't think of a reason why those 2 values need to be the same.

In worst case, each reader can consume a reader slot from a different ring element. In this case there is still one ring element available for writing.

> - How did you choose 7?
I want to have 8 ring element because it is a 2^x value.
To be sure we are lock free, we need on ring element for each accessing thread. I have not counted CO accessing threads but I think 8 should not be reached. We should verify this.
But It should also work with more tasks, because it is very unlikely that 8 threads are in the critical section at the same time. And when it relay happens, the additional threads are locked.

> - Can you use ARRAYSIZE
OK

> - When getValue() fails to read a slot, it goes backward one. This means we sacrifice consistency for speed. We need to make sure people understand this is a trade-off that is part of the control system. Under high load, the control system will possibly serve a stale result when you get().

If there are enough ring elements this should not happen. The value is not stale, because the more recent value is not entirely written.

[William Good (bkgood)]

There appear to be some issues with class ControlObjectValue<T, true>.

First, assuming sizeof(double) <= sizeof(void*) (which is the case on my machine), this class is used for ControlObjectValue<double>. This results in casts like reinterpret_case<void*>(x), where x is a double. These aren't legal casts (and as such, I can't actually compile the branch). To store a double in a QAtomicPointer<void*>, you have to do something like (assuming sizeof(void*)==sizeof(uint64_t) and sizeof(double)==sizeof(uint64_t)):

    QAtomicPointer<void*> qap;
    double x = 1.5;
    qap = reinterpret_cast<void**>(*reinterpret_cast<uint64_t*>(&x));

    void *qap_val = qap;
    double y = *reinterpret_cast<double*>(&qap_val);
    cout << y << endl; // prints 1.5

(some of the complexity exists because QAtomicPointer doesn't overload the deref (*) operator, it provides an implicit type conversion to T*, which means *qap here actually dereferences our stored "pointer", so we have to use void *p = gap which invokes the operator void*() without dereferencing anything)

But regardless, we're not really gaining anything from QAtomicPointer. It's storing a T* in a data member marked volatile (which doesn't even guarantee alignment afaik, which is something we need), and for store and retrieve operations it's not doing anything special (see src/corelib/thread/q{,basic}atomic.h in the qt source). We'd be better off just using a volatile void * in the class, just as a reduction in complexity.

Along these lines:
        return reinterpret_cast<T>(m_container);

As far as I can tell, this is actually trying to cast the QAtomicPointer<void*> to T (an illegal case). This is almost certainly not desirable, but we really want the thing we've stored in the QAP<void*>, cast to T (which requires some bit-fiddling like what I wrote above).

[William Good (bkgood)]

Happened to come across this:

Load a song.
Set a hotcue (if not already set).
Hold down the hotcue key (eg. z).
Press play/pause (either in the UI or on the keyboard).

In truck, it allows you to continue playing the track without holding the hotcue key; in the branch, it segfaults. It happens both with and without the QAtomicPointer code, so I guess it's another change. It seems easily repeatable, so I'm not attaching a backtrace, but I can if needed.

[RJ Skerry-Ryan (rryan)]

RE: My previous comment about atomicity.. I think we can actually get around it without QAtomicPointer, we just need to use compiler-specific alignment directives.

e.g. for GCC: __attribute__ ((aligned (__BIGGEST_ALIGNMENT__)))

[RJ Skerry-Ryan (rryan)]

Now for some comments on the broader changes in the branch outside of COBase:

I think COBase is a nice wait-free base for CO to be based on. Getting rid of the proxies (in this case, turning them into shims) is problematic though. The valueChanged() signal is dangerous and can cause infinite processing loops.

If you listen to valueChanged and some code path in your slot for valueChanged can set the control again then you can have an infinite loop. The proxies are an important part of preventing this because when they queue their change to the control system, they provide a pointer to themselves. CO::sync() then does not deliver the change to the proxy that changed the value.

We are also going to run into many logic errors as we track down the places in Mixxx that have encoded assumptions about the fact that there is an intermediary between setting a COT and the corresponding CO change taking effect.

I think a good solution is one where every control set()/get()s the actual CO value through a proxy that provides a pointer to the original changer. The COBase then emits this pointer in its valueChanged signal. Listening proxies can then check if they originated the set and not emit a valueChanged() in that case.

This brings me to valueChangedFromEngine(double). This signal exists in the first place to be able to differentiate between sets to a control from the current instance of a control or sets to a control from a proxy. What I described from the previous paragraph is just a generalization of valueChangedFromEngine().

[RJ Skerry-Ryan (rryan)]

> > - Why is cReaderSlotCnt the number of concurrent readers allowed also the size of the ring buffer? I can't think of a reason why those 2 values need to be the same.

> In worst case, each reader can consume a reader slot from a different ring element. In this case there is still one ring element available for writing.

If I understand this right, every slot in the ring buffer can support cReaderSlotCnt readers. (i.e. reads fail after cReaderSlotCnt readers are active). When reads fail, a reader moves backward one in the ring buffer to the previous value to read.

So, worst case scenario (for a write), cReaderSlotCnt*cReaderSlotCnt+1 concurrent reads are occurring and there are no available write slots. I don't see how anything related to cReaderSlotCnt preserves an extra slot for writing? We could just have more readers.

> I want to have 8 ring element because it is a 2^x value.
> To be sure we are lock free, we need on ring element for each accessing thread. I have not counted CO accessing threads but I think 8 should not be reached. We should verify this.
> But It should also work with more tasks, because it is very unlikely that 8 threads are in the critical section at the same time. And when it relay happens, the additional threads are locked.

So, to characterize the scenarios when a thread spin-locks:

When (cReaderCnt+1)*cReaderCnt concurrent reads are occurring, then a reader will be spin-locked.
When cReaderCnt+1 concurrent writes are occurring, then a reader will be spin-locked.

When cReaderCnt*cReaderCnt + 1 concurrent reads are occurring, then a writer will be spin-locked.
When cReaderCnt+1 concurrent writes are occurring, then a writer will be spin-locked.

(there is no actual locking, just busy-waiting).

> > - When getValue() fails to read a slot, it goes backward one. This means we sacrifice consistency for speed. We need to make sure people understand this is a trade-off that is part of the control system. Under high load, the control system will possibly serve a stale result when you get().

> If there are enough ring elements this should not happen. The value is not stale, because the more recent value is not entirely written.

This can happen under excessive read-pressure (> cReaderSlotCnt concurrent reads) alone so I don't think that's true... (unless I'm missing something about how this works).

I don't see why cReaderSlotCnt and the ring buffer size need to be related. You could just pick cReaderSlotCnt as INT_MAX and make the ring buffer size 8 and we would effectively never have inconsistent reads under read pressure alone. Isn't cReaderSlotCnt just an arbitrary value we count down to 0 from?

[Daniel Schürmann (daschuer)]

atomicity:

I think it should be really fine to simply revert #3355.
But RJ is right, the native alignment is not guarantied by the c++ standard but actually the compilers will align natively by default.
I have a look at the implementation of QtAtomicInt and they seems not care about alignment.

But it will not hurt to do something like this, just to be sure:

T m_value __attribute__ ((aligned(sizeof(void*)))); // GCC
T __declspec(align(sizeof(void*))) m_value; // MSVC

This is a nice thread:
http://stackoverflow.com/questions/5002046/atomicity-in-c-myth-or-reality

[Daniel Schürmann (daschuer)]

changes outside of COBase:

* Risk of infinite processing loops
Yes this is right. I have already fixed some of those conditions.
My Idea was to solve it in the calling code, to keep the CO core clean and performant.
The key benefit is to get rid of the sync thread.
Do you have a idea to solve it without it?

* intermediary between setting a COT and the corresponding CO change
This should be fixed in the calling code in any case, because this is was on of my goals.

>
> I think a good solution is one where every control set()/get()s the actual CO
> value through a proxy that provides a pointer to the original changer. The
> COBase then emits this pointer in its valueChanged signal. Listening proxies
> can then check if they originated the set and not emit a valueChanged() in
> that case.
>
> This brings me to valueChangedFromEngine(double). This signal exists in the
> first place to be able to differentiate between sets to a control from the
> current instance of a control or sets to a control from a proxy. What I
> described from the previous paragraph is just a generalization of
> valueChangedFromEngine().
>

We might introduce a
setFrom(double value, QObject* source)
function and emit the the source pointer along with the value change event.
Then the receiver can throw the event away if it is it's own.

But I would prefer not to introduce this overhead.
The current rule is very simple and easy to understand:
"If you change a CO you get the signal ... always"

But there is still work to do find all places where this causes issues.

[Daniel Schürmann (daschuer)]

Number of Reader slots:

RJ, you understand the concept correct. I am afraid better then me ;-)

You idea is a relay good workaround for the readers spin lock. I will change the cReaderSlots to Maximum.

But there is still a reader count limit:
Since a writer consumes all reader slots from a writer we have a writer spin-lock if one reader reads on every ring element (cRingSize).

I think this condition is really hard to achieve in real live. Do we have to deal with it?

[RJ Skerry-Ryan (rryan)]

Sometimes it's hard to tell that you're going to get an infinite loop. The loop could even span across multiple different CO changes. It's much easier to code and requires less of a "full view" of the system if the CO you set() does not emit a valueChanged for the set(). I have an idea for how to do this without sacrificing any performance. I'll hack it up in a branch based on this one and send you a merge request.

[Owen Williams (ywwg)]

In my master_sync work, the infinite-CO loop is a humongous pain in the ass. Setting something to master will set other things to slave, and setting other things to slave might set something else to master... If I had a simple call to ask "did I initiate this chain of events?" then I could avoid a lot of ugly code I've had to create.

[RJ Skerry-Ryan (rryan)]

Also, I just noticed the change to ControlObjectThreadMain -- that needs to be reverted. When you use a COTM/COTW in Mixxx code you are declaring that valueChanged signals are expected to be delivered by the GUI/main thread so we need to save this behavior or we will run into trouble.

Without posting the event to the Qt event queue as it was implemented there's no guarantee that a valueChanged signal coming from the ControlObject will be received on the GUI thread.

review: Needs Fixing

[lp:~mixxxdevelopers/mixxx/atomic-co]

3360. By Daniel Schürmann on 2013-05-15

merged rollback -r 3360 lp:~rryan/mixxx/atomic-co

3361. By Daniel Schürmann on 2013-05-15

set cReaderSlotCnt = std::numeric_limits<int>::max()

3362. By Daniel Schürmann on 2013-05-15

added alignement keywords

[RJ Skerry-Ryan (rryan)]

I added COTM main-thread proxying back in lp:~rryan/mixxx/atomic-co.

[lp:~mixxxdevelopers/mixxx/atomic-co]

3363. By Daniel Schürmann on 2013-05-16

merged from lp:~rryan/mixxx/atomic-co

[Daniel Schürmann (daschuer)]

Here some results:

* I think the CO is registered twice: In ControlObject::ControlObject() and in ControlDoublePrivate::getControl()
* it is not clear where the home of m_sqCOHash is, for me it should move to ControlDoublePrivate
* all static functions should have the leading comment // static
* control.cpp/h should be renamed to controldoubleprivate.cpp/h
* DRY violation in overloaded ControlObject::ControlObject()
* setMidiParameter needs a pSender
* gcc complains about the missing virtual destructors in the *Behaviour classes
* i do not like to distingish between valueChanged(v) and valueChangedByThis(v), because it is most likely that if an object wants to receive valueChangedByThis(v) it will also receive valueChanged(v).
For this propose we should implement a new proxy which sends out pSender, or allow to use ControlDoublePrivate directly

please not the merge request with additional changes

review: Needs Fixing

[RJ Skerry-Ryan (rryan)]

On May 16, 2013 7:46 PM, "Daniel Schürmann" <email address hidden> wrote:
>
> Review: Needs Fixing
>
> Here some results:
>
> * I think the CO is registered twice: In ControlObject::ControlObject()
and in ControlDoublePrivate::getControl()

On mobile - sorry for brevity.

We have to keep this until we get rid of CO::getControl

> * it is not clear where the home of m_sqCOHash is, for me it should move
to control double private

Agree but see above.

> * all static functions should have the leading comment // static

Thx will change

> * control.cpp/h should be renamed to controldoubleprivate.cpp/h

I think all control implementations should go in control.h so there's one
header to include. I could see this not being a public part of the control
system so maybe that makes sense.

> * DRY violation in overloaded ControlObject::ControlObject()

Will fix with a common init method

> * setMidiParameter needs a pSender

The sender in this case is the midi controller and the midi controller uses
raw COs instead of creating a COT so its not correct to do this how you did
... When MController gets changed to use COT then that should be the sender

> * gcc complains about the missing virtual destructors in the *Behaviour
classes

K can fix

> * i do not like to distingish between valueChanged(v) and
valueChangedByThis(v), because it is most likely that if an object wants to
receive valueChangedByThis(v) it will also receive valueChanged(v).

Yes but that's because by default code is not safe until carefully reviewed
for infinite loop prevention. Once it is reviewed it is natural we would
like to respond to both internal and external. There may be cases in the
future where you would only want to react to internally sourced changes.

> For this propose we should implement a new proxy which sends out pSender,
or allow to use ControlDoublePrivate directly

I've explained why we need this signal -- it's safer for writing code
because it avoids infinite feedback loops and it allows you to distinguish
between local and remote value changes (which is already used today in
mixxx).

Can you explain why you think we should not do this?

>
> please not the merge request with additional changes
> --
> https://code.launchpad.net/~mixxxdevelopers/mixxx/atomic-co/+merge/153696
> You are reviewing the proposed merge of
lp:~mixxxdevelopers/mixxx/atomic-co into lp:mixxx.

[Daniel Schürmann (daschuer)]

> > * i do not like to distingish between valueChanged(v) and
> valueChangedByThis(v), because it is most likely that if an object wants to
> receive valueChangedByThis(v) it will also receive valueChanged(v).
>
> Yes but that's because by default code is not safe until carefully reviewed
> for infinite loop prevention. Once it is reviewed it is natural we would
> like to respond to both internal and external. There may be cases in the
> future where you would only want to react to internally sourced changes.
>
> > For this propose we should implement a new proxy which sends out pSender,
> or allow to use ControlDoublePrivate directly
>
> I've explained why we need this signal -- it's safer for writing code
> because it avoids infinite feedback loops and it allows you to distinguish
> between local and remote value changes (which is already used today in
> mixxx).
>
> Can you explain why you think we should not do this?
>

I the meanwhile I am convinced that we don't need the loop back signal at all.
It is allays lower overhead to call the slot manually if required and it is
more easy to track when reading the code.

[lp:~mixxxdevelopers/mixxx/atomic-co]

3364. By RJ Skerry-Ryan on 2013-05-17

Static comments.

3365. By RJ Skerry-Ryan on 2013-05-17

Behavior implementations to cpp.

3366. By RJ Skerry-Ryan on 2013-05-17

Eliminate duplication in ControlObject constructor.

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2013-05-15 06:09:40 +0000
+++ mixxx/build/depends.py	2013-05-17 16:35:30 +0000
@@ -420,18 +420,18 @@
         sources = ["mixxxkeyboard.cpp",
 
                    "configobject.cpp",
+                   "control/control.cpp",
+                   "control/controlbehavior.cpp",
                    "controlobjectthread.cpp",
                    "controlobjectthreadwidget.cpp",
                    "controlobjectthreadmain.cpp",
                    "controlevent.cpp",
                    "controllogpotmeter.cpp",
                    "controlobject.cpp",
-                   "controlnull.cpp",
                    "controlpotmeter.cpp",
                    "controllinpotmeter.cpp",
                    "controlpushbutton.cpp",
                    "controlttrotary.cpp",
-                   "controlbeat.cpp",
 
                    "dlgpreferences.cpp",
                    "dlgprefsound.cpp",
@@ -455,7 +455,6 @@
 
                    "engine/engineworker.cpp",
                    "engine/engineworkerscheduler.cpp",
-                   "engine/syncworker.cpp",
                    "engine/enginebuffer.cpp",
                    "engine/enginebufferscale.cpp",
                    "engine/enginebufferscaledummy.cpp",

=== added file 'mixxx/res/controllers/Hercules DJ Console RMX 2.midi.xml'
--- mixxx/res/controllers/Hercules DJ Console RMX 2.midi.xml	1970-01-01 00:00:00 +0000
+++ mixxx/res/controllers/Hercules DJ Console RMX 2.midi.xml	2013-05-17 16:35:30 +0000
@@ -0,0 +1,963 @@
+<MixxxMIDIPreset mixxxVersion="1.10.1+" schemaVersion="1">
+	<info>
+  <!-- In Geany, go to Document and then Fold All for easier format. -->
+		<name>Hercules DJ Console RMX 2</name>
+		<author>Circuitfry</author>
+		<description>This console's mapping comes with a script.</description>
+	</info>
+ <controller id="DJConsole Rmx2">
+		<scriptfiles>
+			<file filename="Hercules-DJ-Console-RMX-2-scripts.js" functionprefix="DJCRMX2"/>
+		</scriptfiles>
+   <controls>
+    <!-- General Controls -->
+    <control><!-- Master Volume Pt 1 -->
+     <status>0xb0</status>
+     <midino>0x44</midino>
+     <group>[Master]</group>
+     <key>volume</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Master HeadMix Pt 1 -->
+     <status>0xb0</status>
+     <midino>0x46</midino>
+     <group>[Master]</group>
+     <key>headMix</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Master Crossfader Pt 1 -->
+     <status>0xb0</status>
+     <midino>0x48</midino>
+     <group>[Master]</group>
+     <key>crossfader</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Microphone -->
+     <status>0x90</status> <!-- ??? -->
+     <midino>0x48</midino>
+     <group>[Microphone]</group>
+     <key>DJCRMX2.micSwitch</key>
+     <description>Utilize Microphone</description>
+     <options>
+      <Script-Binding/>
+     </options>
+    </control>
+    <control><!-- Select UP -->
+     <status>0x90</status>
+     <midino>0x45</midino>
+     <group>[Playlist]</group>
+     <key>SelectPrevTrack</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Select DOWN -->
+     <status>0x90</status>
+     <midino>0x46</midino>
+     <group>[Playlist]</group>
+     <key>SelectNextTrack</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Select LEFT -->
+     <status>0x90</status>
+     <midino>0x44</midino>
+     <group>[Playlist]</group>
+     <key>SelectPrevPlaylist</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Select RIGHT -->
+     <status>0x90</status>
+     <midino>0x43</midino>
+     <group>[Playlist]</group>
+     <key>SelectNextPlaylist</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <!-- General Controls -->
+    <!-- Deck Controls -->
+    <control><!-- Left Load Song -->
+     <status>0x90</status>
+     <midino>0x24</midino>
+     <group>[Channel1]</group>
+     <key>LoadSelectedTrack</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Load Song -->
+     <status>0x90</status>
+     <midino>0x35</midino>
+     <group>[Channel2]</group>
+     <key>LoadSelectedTrack</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- L Play -->
+     <status>0x90</status>
+     <midino>0x21</midino>
+     <group>[Channel1]</group>
+     <key>play</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- R Play -->
+     <status>0x90</status>
+     <midino>0x32</midino>
+     <group>[Channel2]</group>
+     <key>play</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Headphones -->
+     <status>0x90</status>
+     <midino>0x2e</midino>
+     <group>[Channel1]</group>
+     <key>pfl</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Headphones -->
+     <status>0x90</status>
+     <midino>0x3F</midino>
+     <group>[Channel2]</group>
+     <key>pfl</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- L Cue -->
+     <status>0x90</status>
+     <midino>0x22</midino>
+     <group>[Channel1]</group>
+     <key>cue_default</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- R Cue -->
+     <status>0x90</status>
+     <midino>0x33</midino>
+     <group>[Channel2]</group>
+     <key>cue_default</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- L Sync -->
+     <status>0x90</status>
+     <midino>0x23</midino>
+     <group>[Channel1]</group>
+     <key>beatsync</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- R Sync -->
+     <status>0x90</status>
+     <midino>0x34</midino>
+     <group>[Channel2]</group>
+     <key>beatsync</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- L Tempo Slider Pt 1 -->
+     <status>0xb0</status>
+     <midino>0x36</midino>
+     <group>[Channel1]</group>
+     <key>rate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- R Tempo Slider Pt 1 -->
+     <status>0xb0</status>
+     <midino>0x38</midino>
+     <group>[Channel2]</group>
+     <key>rate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- L Fader Pt 1 -->
+     <status>0xb0</status>
+     <midino>0x3a</midino>
+     <group>[Channel1]</group>
+     <key>volume</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- R Fader Pt 1 -->
+     <status>0xb0</status>
+     <midino>0x4a</midino>
+     <group>[Channel2]</group>
+     <key>volume</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Fast Rewind -->
+     <status>0x90</status>
+     <midino>0x26</midino>
+     <group>[Channel1]</group>
+     <key>back</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Fast Rewind -->
+     <status>0x90</status>
+     <midino>0x37</midino>
+     <group>[Channel2]</group>
+     <key>back</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Fast Forward -->
+     <status>0x90</status>
+     <midino>0x27</midino>
+     <group>[Channel1]</group>
+     <key>fwd</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Fast Forward -->
+     <status>0x90</status>
+     <midino>0x38</midino>
+     <group>[Channel2]</group>
+     <key>fwd</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Pitch Down -->
+     <status>0x90</status>
+     <midino>0x2C</midino>
+     <group>[Channel1]</group>
+     <key>rate_temp_down_small</key>
+     <description>L Pitch Down</description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Pitch Up -->
+     <status>0x90</status>
+     <midino>0x2D</midino>
+     <group>[Channel1]</group>
+     <key>rate_temp_up_small</key>
+     <description>L Pitch Down</description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Pitch Down -->
+     <status>0x90</status>
+     <midino>0x3D</midino>
+     <group>[Channel2]</group>
+     <key>rate_temp_down_small</key>
+     <description>R Pitch Down</description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Pitch Up -->
+     <status>0x90</status>
+     <midino>0x3E</midino>
+     <group>[Channel2]</group>
+     <key>rate_temp_up_small</key>
+     <description>R Pitch Down</description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <!-- Deck Controls -->
+    <!-- Jog Wheels -->
+    <control><!-- Left Press Down -->
+     <status>0x90</status>
+     <midino>0x2F</midino>
+     <group>[Channel1]</group>
+     <key>DJCRMX2.wheelPress</key>
+     <description>Jog Wheel L Pressed Down</description>
+     <options>
+     <Script-Binding/>
+     </options>
+    </control>
+    <control><!-- Right Press Down -->
+     <status>0x90</status>
+     <midino>0x40</midino>
+     <group>[Channel2]</group>
+     <key>DJCRMX2.wheelPress</key>
+     <description>Jog Wheel R Pressed Down</description>
+     <options>
+     <Script-Binding/>
+     </options>
+    </control>
+    <control><!-- Left Spin -->
+     <status>0xB0</status>
+     <midino>0x30</midino>
+     <group>[Channel1]</group>
+     <key>DJCRMX2.wheelTurn</key>
+     <description>Wheel Turning (regular)</description>
+     <options>
+     <Script-Binding/>
+     </options>
+    </control>
+    <control><!-- Right Spin -->
+     <status>0xB0</status>
+     <midino>0x31</midino>
+     <group>[Channel2]</group>
+     <key>DJCRMX2.wheelTurn</key>
+     <description>Wheel Turning (regular)</description>
+     <options>
+     <Script-Binding/>
+     </options>
+    </control>
+    <control><!-- Left Scratch -->
+     <status>0xB0</status>
+     <midino>0x32</midino>
+     <group>[Channel1]</group>
+     <key>DJCRMX2.wheelTurn</key>
+     <description>Wheel Turning (scratching)</description>
+     <options>
+     <Script-Binding/>
+     </options>
+    </control>
+    <control><!-- Right Scratch -->
+     <status>0xB0</status>
+     <midino>0x33</midino>
+     <group>[Channel2]</group>
+     <key>DJCRMX2.wheelTurn</key>
+     <description>Wheel Turning (scratching)</description>
+     <options>
+     <Script-Binding/>
+     </options>
+    </control>
+    <!-- Jog Wheels -->
+    <!-- EQ Controls -->
+    <control><!-- Left Knob High 1 -->
+     <status>0xb0</status>
+     <midino>0x3c</midino>
+     <group>[Channel1]</group>
+     <key>filterHigh</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Knob Mid 1 -->
+     <status>0xb0</status>
+     <midino>0x3e</midino>
+     <group>[Channel1]</group>
+     <key>filterMid</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Knob Low 1 -->
+     <status>0xb0</status>
+     <midino>0x40</midino>
+     <group>[Channel1]</group>
+     <key>filterLow</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Left Kill High -->
+				 <status>0x90</status>
+    	<midino>0x28</midino>
+     	<group>[Channel1]</group>
+     	<key>filterHighKill</key>
+    	<description>High Left Kill</description>
+    	<options>
+    		<normal/>
+    	</options>
+    </control>
+    <control><!-- Left Kill Mid -->
+				 <status>0x90</status>
+    	<midino>0x29</midino>
+    	<group>[Channel1]</group>
+    	<key>filterMidKill</key>
+    	<description>Mid Left Kill</description>
+    	<options>
+    		<normal/>
+    	</options>
+    </control>
+    <control><!-- Left Kill Low -->
+				 <status>0x90</status>
+    	<midino>0x2A</midino>
+    	<group>[Channel1]</group>
+    	<key>filterLowKill</key>
+    	<description>Low Left Kill</description>
+    	<options>
+    		<normal/>
+    	</options>
+    </control>
+    <control><!-- Right Knob High 1 -->
+     <status>0xb0</status>
+     <midino>0x4c</midino>
+     <group>[Channel2]</group>
+     <key>filterHigh</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Knob Mid 1 -->
+     <status>0xb0</status>
+     <midino>0x4e</midino>
+     <group>[Channel2]</group>
+     <key>filterMid</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Knob Low 1 -->
+     <status>0xb0</status>
+     <midino>0x50</midino>
+     <group>[Channel2]</group>
+     <key>filterLow</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Right Kill High -->
+				 <status>0x90</status>
+    	<midino>0x39</midino>
+    	<group>[Channel2]</group>
+    	<key>filterHighKill</key>
+    	<description>High Right Kill</description>
+    	<options>
+    		<normal/>
+    	</options>
+     </control>
+    <control><!-- Right Kill Mid -->
+				 <status>0x90</status>
+    	<midino>0x3A</midino>
+    	<group>[Channel2]</group>
+    	<key>filterMidKill</key>
+    	<description>Mid Right Kill</description>
+    	<options>
+    		<normal/>
+    	</options>
+    </control>
+    <control><!-- Right Kill Low -->
+				 <status>0x90</status>
+    	<midino>0x3B</midino>
+    	<group>[Channel2]</group>
+    	<key>filterLowKill</key>
+    	<description>Low Right Kill</description>
+    	<options>
+    		<normal/>
+    	</options>
+    </control>
+    <!-- EQ Controls -->
+    <!-- Samplers Controls [Sample Mode] 25% -->
+    <control><!-- S1 Play -->
+     <status>0x90</status>
+     <midino>0x05</midino>
+     <group>[Sampler1]</group>
+     <key>play</key>
+     <description></description>
+     <options>
+       <normal/>
+     </options>
+    </control>
+    <control><!-- S2 Play -->
+     <status>0x90</status>
+     <midino>0x6</midino>
+     <group>[Sampler2]</group>
+     <key>play</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S3 Play -->
+     <status>0x90</status>
+     <midino>0x7</midino>
+     <group>[Sampler3]</group>
+     <key>play</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S4 Play -->
+     <status>0x90</status>
+     <midino>0x8</midino>
+     <group>[Sampler4]</group>
+     <key>play</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S1 Keylock -->
+     <status>0x90</status>
+     <midino>0x15</midino>
+     <group>[Sampler1]</group>
+     <key>keylock</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S2 Keylock -->
+     <status>0x90</status>
+     <midino>0x16</midino>
+     <group>[Sampler2]</group>
+     <key>keylock</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S3 Keylock -->
+     <status>0x90</status>
+     <midino>0x17</midino>
+     <group>[Sampler3]</group>
+     <key>keylock</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S4 Keylock -->
+     <status>0x90</status>
+     <midino>0x18</midino>
+     <group>[Sampler4]</group>
+     <key>keylock</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S1 Tempo Tap [UNIMPLEMENTED] -->
+     <status>0xb0</status>
+     <midino>0x15</midino>
+     <group>[Sampler1]</group>
+     <key>bpm</key>
+     <description></description>
+     <options>
+       <normal/>
+     </options>
+    </control>
+    <control><!-- S2 Tempo Tap [UNIMPLEMENTED] -->
+     <status>0xb0</status>
+     <midino>0x16</midino>
+     <group>[Sampler2]</group>
+     <key>bpm</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S3 Tempo Tap [UNIMPLEMENTED] -->
+     <status>0xb0</status>
+     <midino>0x17</midino>
+     <group>[Sampler3]</group>
+     <key>bpm</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S4 Tempo Tap [UNIMPLEMENTED] -->
+     <status>0xb0</status>
+     <midino>0x18</midino>
+     <group>[Sampler4]</group>
+     <key>bpm</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S1 Headphones [UNIMPLEMENTED] -->
+     <status>0xb0</status>
+     <midino>0x5</midino>
+     <group>[Sampler1]</group>
+     <key>pfl</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S2 Headphones [UNIMPLEMENTED] -->
+     <status>0xb0</status>
+     <midino>0x6</midino>
+     <group>[Sampler2]</group>
+     <key>pfl</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S3 Headphones [UNIMPLEMENTED] -->
+     <status>0xb0</status>
+     <midino>0x7</midino>
+     <group>[Sampler3]</group>
+     <key>pfl</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- S4 Headphones [UNIMPLEMENTED] -->
+     <status>0x80</status>
+     <midino>0x30</midino>
+     <group>[Sampler4]</group>
+     <key>pfl</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <!-- Samplers Controls [Sample Mode] -->
+    <!-- Hotcue Controls [Cue Mode] 0% -->
+    <control><!-- LC1 Activate -->
+     <status>0x90</status>
+     <midino>0x9</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_1_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LC2 Activate -->
+     <status>0x90</status>
+     <midino>0x0A</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_2_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LC3 Activate -->
+     <status>0x90</status>
+     <midino>0x0b</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_3_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LC4 Activate -->
+     <status>0x90</status>
+     <midino>0x0c</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_4_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LC1 Clear -->
+     <status>0xB0</status>
+     <midino>0x09</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_1_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LC2 Clear -->
+     <status>0xB0</status>
+     <midino>0x0a</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_2_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LC3 Clear -->
+     <status>0xB0</status>
+     <midino>0x0b</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_3_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LC4 Clear -->
+     <status>0xB0</status>
+     <midino>0x0C</midino>
+     <group>[Channel1]</group>
+     <key>hotcue_4_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC1 Activate -->
+     <status>0x90</status>
+     <midino>0x19</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_1_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC2 Activate -->
+     <status>0x90</status>
+     <midino>0x1a</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_2_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC3 Activate -->
+     <status>0x90</status>
+     <midino>0x1b</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_3_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC4 Activate -->
+     <status>0x90</status>
+     <midino>0x1c</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_4_activate</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC1 Clear [Should be Shift+RC1, v. 2.0] -->
+     <status>0xB0</status>
+     <midino>0x19</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_1_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC2 Clear -->
+     <status>0xB0</status>
+     <midino>0x1a</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_2_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC3 Clear -->
+     <status>0xB0</status>
+     <midino>0x1b</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_3_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RC4 Clear -->
+     <status>0xB0</status>
+     <midino>0x1c</midino>
+     <group>[Channel2]</group>
+     <key>hotcue_4_clear</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <!-- Hotcue Controls [Cue Mode] -->
+    <!-- Effects Controls [Effect Mode] 70% -->
+    <control><!-- LF On/Off x9 -->
+     <status>0x90</status>
+     <midino>0x1</midino>
+     <group>[Channel1]</group>
+     <key>flanger</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RF On/Off x9 -->
+     <status>0x90</status>
+     <midino>0x11</midino>
+     <group>[Channel2]</group>
+     <key>flanger</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Flanger Period L -->
+     <status>0xA0</status>
+     <midino>0x02</midino>
+     <group>[Flanger]</group>
+     <key>lfoPeriod</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Flanger Depth L -->
+     <status>0xA0</status>
+     <midino>0x03</midino>
+     <group>[Flanger]</group>
+     <key>lfoDepth</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- Flanger Delay L -->
+     <status>0xA0</status>
+     <midino>0x04</midino>
+     <group>[Flanger]</group>
+     <key>lfoDelay</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <!-- Effects Controls [Effect Mode] -->
+    <!-- Looping Controls [Loop Mode] 0% -->
+    <control><!-- RLoop 4 -->
+     <status>0x90</status>
+     <midino>0x1d</midino>
+     <group>[Channel2]</group>
+     <key>beatloop_4_toggle</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RLoop 2 -->
+     <status>0x90</status>
+     <midino>0x1e</midino>
+     <group>[Channel2]</group>
+     <key>beatloop_2_toggle</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RLoop 1 -->
+     <status>0x90</status>
+     <midino>0x1f</midino>
+     <group>[Channel2]</group>
+     <key>beatloop_1_toggle</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- RLoop 1/2 -->
+     <status>0x90</status>
+     <midino>0x20</midino>
+     <group>[Channel2]</group>
+     <key>beatloop_0.5_toggle</key>
+     <description></description>
+     <options>
+       <normal/>
+     </options>
+    </control>
+    <control><!-- LLoop 4 -->
+     <status>0x90</status>
+     <midino>0x0D</midino>
+     <group>[Channel1]</group>
+     <key>beatloop_4_toggle</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LLoop 2 -->
+     <status>0x90</status>
+     <midino>0x0e</midino>
+     <group>[Channel1]</group>
+     <key>beatloop_2_toggle</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LLoop 1 -->
+     <status>0x90</status>
+     <midino>0x0f</midino>
+     <group>[Channel1]</group>
+     <key>beatloop_1_toggle</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <control><!-- LLoop 1/2 -->
+     <status>0x90</status>
+     <midino>0x10</midino>
+     <group>[Channel1]</group>
+     <key>beatloop_0.5_toggle</key>
+     <description></description>
+     <options>
+      <normal/>
+     </options>
+    </control>
+    <!-- Looping Controls [Loop Mode] -->
+    <!-- End of Controls -->
+   </controls>
+  <outputs/>
+ </controller>
+</MixxxMIDIPreset>    

=== added file 'mixxx/res/controllers/Hercules-DJ-Console-RMX-2-scripts.js'
--- mixxx/res/controllers/Hercules-DJ-Console-RMX-2-scripts.js	1970-01-01 00:00:00 +0000
+++ mixxx/res/controllers/Hercules-DJ-Console-RMX-2-scripts.js	2013-05-17 16:35:30 +0000
@@ -0,0 +1,128 @@
+/*╔══:::Made Lovingly By Circuitfry:::═════════════════════════════════╗
+  ║     Hercules DJConsole RMX 2 Mapping Scripts v. 0.1.3              ║
+  ╚════════════════════════════════════════════════════════════════════╝
+  * Version 0.1.0: Basic Midi Wizard Mapping
+  * Version 0.1.1: Partially-Functional platters (version 1).
+  * Version 0.1.2: Functional platters (version 1)
+  * Version 0.1.3: Functional EQ Kill/Pitch Bending buttons
+                   Functional Looping/Sample/Effect pads
+                   Bugfix: Source 2 Gain knob doesn't load tracks.
+                   Overhaul: MIDI Scripting file.
+    Worklog: Need to implement Microphone/Source1/Source2 input.
+  * Note 1: [DEP] Means the command is meant for Mixxx v1.10.x + below.
+  * Note 2: [FUT] Means the command is meant for Mixxx v1.11.x + above.
+*/
+function DJCRMX2(){}
+DJCRMX2.scratching = [];
+
+/*  [ Function init ] - Version 0.1.3
+  * Initiates some global variables and assigns an ID. Required.
+*/
+DJCRMX2.init = function(id){	
+ DJCRMX2.id = id;
+ DJCRMX2.scratching[1]=false;
+ DJCRMX2.scratching[2]=false;
+ engine.setValue("[Microphone]","enabled",0);
+ engine.setValue("[Microphone]","talkover",0);
+}
+
+/*  [ Function wheelPress ] - Version 0.1.2
+  * Detects whether a jog wheel is pressed or not and sets a specific
+  * variable on and off accordingly.
+*/
+DJCRMX2.wheelPress = function (channel, control, value, status, group){
+ if (status == 0x90) // If status #144 is active (2 possibilities)
+ {
+  if (value == 0x7F) // And the jog wheel is pressed down:
+  {  /*  engine.scratchEnable(int,int,float,float,float,bool);
+       * [ int deck ]              Which track/platter is playing?
+       * [ int intervalsPerRev ]   # of MIDI signals sent in 1 spin.
+       * [ float rpm ]             Imaginary vinyl rotation speed.
+       * [ float alpha ]           Just a fine-tuning variable.
+       * [ float beta ]            Just a fine-tuning variable.
+       * [ bool ramp ]             As far as I know, nothing...
+     */
+      var alpha = 1.0/8;
+      var beta = alpha/32;
+      if(group=="[Channel1]")
+      {
+       engine.scratchEnable(1, 250, 50, alpha, beta);
+       DJCRMX2.scratching[1] = true; //[DEP]
+	  }
+	  if(group=="[Channel2]")
+	  {
+	   engine.scratchEnable(2, 250, 50, alpha, beta);
+	   DJCRMX2.scratching[2] = true; //[DEP]
+	  }
+      
+  }
+  if (value == 0x00 ) // If the jog wheel is released:
+  {
+   if(group=="[Channel1]")
+   {
+    DJCRMX2.scratching[1] = false; // <- v1.10.x and below
+    engine.scratchDisable(1);
+   }
+   if(group=="[Channel2]")
+   {
+    DJCRMX2.scratching[2] = false; // <- v1.10.x and below
+   engine.scratchDisable(2);
+   }
+  }
+ }
+ else //Default setting where button is not held down.
+ {
+  DJCRMX2.scratching[1] = false;  // Only for v1.10.x and below
+  DJCRMX2.scratching[2] = false;  // Only for v1.10.x and below
+  engine.scratchDisable(1);
+  engine.scratchDisable(2);
+ }
+ return;
+}
+ 
+/*  [ Function wheelTurn ] - Version 0.1.2
+  * Pays attention to the current deck, checks scratching, affects the
+  * song accordingly.
+*/
+DJCRMX2.wheelTurn = function (channel, control, value, status, group){
+ var newValue=0;
+ // Spinning backwards = 127 or less (less meaning faster)
+ // Spinning forwards  = 1 or more (more meaning faster)
+ if (value-64 > 0) newValue = (value-128);
+ else newValue=value;
+ //if (!engine.isScratching(DJCRMX2.currentDeck)) // [FUT]
+ if(group=="[Channel1]")
+ {
+  if(DJCRMX2.scratching[1]==true) {engine.scratchTick(1,newValue);return;}
+ }
+ else if(group=="[Channel2]")
+ {
+  if(DJCRMX2.scratching[2]==true) {engine.scratchTick(2,newValue);return;}
+ }
+ engine.setValue(group, "jog", newValue);
+ return;
+}
+
+DJCRMX2.micSwitch = function (channel, control, value, status) //???
+{
+ if(status == 0x90 && control == 0x48 && value == 0x7F)
+ {
+  engine.setValue("[Microphone]","enabled",1);
+  engine.setValue("[Microphone]","talkover",1);
+ }
+ if(status == 0x90 && control == 0x48 && value == 0x00)
+ {
+  engine.setValue("[Microphone]","enabled",0);
+  engine.setValue("[Microphone]","talkover",0);
+ }
+}
+
+/*  [ Function shutdown ] - Version 0.1.3
+  * Sets variables down for shutoff.
+*/
+DJCRMX2.shutdown = function(id){
+ DJCRMX2.scratching[1]=false;
+ DJCRMX2.scratching[2]=false;
+ engine.setValue("[Microphone]","enabled",0);
+ engine.setValue("[Microphone]","talkover",0);
+}

=== added directory 'mixxx/src/control'
=== added file 'mixxx/src/control/control.cpp'
--- mixxx/src/control/control.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/control/control.cpp	2013-05-17 16:35:30 +0000
@@ -0,0 +1,132 @@
+#include <QtDebug>
+#include <QMutexLocker>
+
+#include "control/control.h"
+
+#include "util/stat.h"
+#include "util/timer.h"
+
+// Static member variable definition
+QHash<ConfigKey, ControlDoublePrivate*> ControlDoublePrivate::m_sqCOHash;
+QMutex ControlDoublePrivate::m_sqCOHashMutex;
+
+ControlDoublePrivate::ControlDoublePrivate()
+        : m_bIgnoreNops(true),
+          m_bTrack(false) {
+    m_defaultValue.setValue(0);
+    m_value.setValue(0);
+}
+
+ControlDoublePrivate::ControlDoublePrivate(ConfigKey key,
+                                             bool bIgnoreNops, bool bTrack)
+        : m_key(key),
+          m_bIgnoreNops(bIgnoreNops),
+          m_bTrack(bTrack),
+          m_trackKey("control " + m_key.group + "," + m_key.item),
+          m_trackType(Stat::UNSPECIFIED),
+          m_trackFlags(Stat::COUNT | Stat::SUM | Stat::AVERAGE |
+                       Stat::SAMPLE_VARIANCE | Stat::MIN | Stat::MAX) {
+    m_defaultValue.setValue(0);
+    m_value.setValue(0);
+
+    m_sqCOHashMutex.lock();
+    m_sqCOHash.insert(m_key, this);
+    m_sqCOHashMutex.unlock();
+
+    if (m_bTrack) {
+        // TODO(rryan): Make configurable.
+        Stat::track(m_trackKey, static_cast<Stat::StatType>(m_trackType),
+                    static_cast<Stat::ComputeFlags>(m_trackFlags),
+                    m_value.getValue());
+    }
+}
+
+ControlDoublePrivate::~ControlDoublePrivate() {
+    m_sqCOHashMutex.lock();
+    m_sqCOHash.remove(m_key);
+    m_sqCOHashMutex.unlock();
+}
+
+// static
+ControlDoublePrivate* ControlDoublePrivate::getControl(
+    const ConfigKey& key, bool bCreate, bool bIgnoreNops, bool bTrack) {
+    QMutexLocker locker(&m_sqCOHashMutex);
+    QHash<ConfigKey, ControlDoublePrivate*>::const_iterator it = m_sqCOHash.find(key);
+    if (it != m_sqCOHash.end()) {
+        return it.value();
+    }
+    locker.unlock();
+
+    ControlDoublePrivate* pControl = NULL;
+    if (bCreate) {
+        pControl = new ControlDoublePrivate(key, bIgnoreNops, bTrack);
+        locker.relock();
+        m_sqCOHash.insert(key, pControl);
+        locker.unlock();
+    }
+
+    if (pControl == NULL) {
+        qWarning() << "ControlDoublePrivate::getControl returning NULL for ("
+                   << key.group << "," << key.item << ")";
+    }
+
+    return pControl;
+}
+
+double ControlDoublePrivate::get() const {
+    return m_value.getValue();
+}
+
+void ControlDoublePrivate::reset(QObject* pSender) {
+    double defaultValue = m_defaultValue.getValue();
+    set(defaultValue, pSender);
+}
+
+void ControlDoublePrivate::set(const double& value, QObject* pSender) {
+    if (m_bIgnoreNops && get() == value) {
+        return;
+    }
+
+    double dValue = value;
+    // The behavior says to ignore the set, ignore it.
+    ControlNumericBehavior* pBehavior = m_pBehavior;
+    if (pBehavior && !pBehavior->setFilter(&dValue)) {
+        return;
+    }
+    m_value.setValue(dValue);
+    emit(valueChanged(dValue, pSender));
+
+    if (m_bTrack) {
+        Stat::track(m_trackKey, static_cast<Stat::StatType>(m_trackType),
+                    static_cast<Stat::ComputeFlags>(m_trackFlags), dValue);
+    }
+}
+
+ControlNumericBehavior* ControlDoublePrivate::setBehavior(ControlNumericBehavior* pBehavior) {
+    return m_pBehavior.fetchAndStoreRelaxed(pBehavior);
+}
+
+void ControlDoublePrivate::setWidgetParameter(double dParam, QObject* pSetter) {
+    ControlNumericBehavior* pBehavior = m_pBehavior;
+    set(pBehavior ? pBehavior->widgetParameterToValue(dParam) : dParam, pSetter);
+}
+
+double ControlDoublePrivate::getWidgetParameter() const {
+    ControlNumericBehavior* pBehavior = m_pBehavior;
+    return pBehavior ? pBehavior->valueToWidgetParameter(get()) : get();
+}
+
+void ControlDoublePrivate::setMidiParameter(MidiOpCode opcode, double dParam) {
+    ControlNumericBehavior* pBehavior = m_pBehavior;
+    if (pBehavior) {
+        pBehavior->setValueFromMidiParameter(opcode, dParam, this);
+    } else {
+        set(dParam, NULL);
+    }
+}
+
+double ControlDoublePrivate::getMidiParameter() const {
+    ControlNumericBehavior* pBehavior = m_pBehavior;
+    return pBehavior ? pBehavior->valueToMidiParameter(get()) : get();
+}
+

=== added file 'mixxx/src/control/control.h'
--- mixxx/src/control/control.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/control/control.h	2013-05-17 16:35:30 +0000
@@ -0,0 +1,95 @@
+#ifndef CONTROL_H
+#define CONTROL_H
+
+#include <QHash>
+#include <QMutex>
+#include <QString>
+#include <QObject>
+#include <QAtomicPointer>
+
+#include "control/controlbehavior.h"
+#include "control/controlvalue.h"
+#include "configobject.h"
+
+class ControlDoublePrivate : public QObject {
+    Q_OBJECT
+  public:
+    ControlDoublePrivate();
+    ControlDoublePrivate(ConfigKey key, bool bIgnoreNops, bool bTrack);
+    virtual ~ControlDoublePrivate();
+
+    // Gets the ControlDoublePrivate matching the given ConfigKey. If bCreate
+    // is true, allocates a new ControlDoublePrivate for the ConfigKey if one
+    // does not exist.
+    static ControlDoublePrivate* getControl(
+        const ConfigKey& key,
+        bool bCreate, bool bIgnoreNops=true, bool bTrack=false);
+    static inline ControlDoublePrivate* getControl(
+        const QString& group, const QString& item,
+        bool bCreate, bool bIgnoreNops=true, bool bTrack=false) {
+        ConfigKey key(group, item);
+        return getControl(key, bCreate, bIgnoreNops, bTrack);
+    }
+
+    // Sets the control value.
+    void set(const double& value, QObject* pSetter);
+    // Gets the control value.
+    double get() const;
+    // Resets the control value to its default.
+    void reset(QObject* pSetter);
+
+    // Set the behavior to be used when setting values and translating between
+    // parameter and value space. Returns the previously set behavior (if any).
+    // Caller must handle appropriate destruction of the previous behavior or
+    // memory will leak.
+    ControlNumericBehavior* setBehavior(ControlNumericBehavior* pBehavior);
+
+    void setWidgetParameter(double dParam, QObject* pSetter);
+    double getWidgetParameter() const;
+
+    void setMidiParameter(MidiOpCode opcode, double dParam);
+    double getMidiParameter() const;
+
+    inline bool ignoreNops() const {
+        return m_bIgnoreNops;
+    }
+
+    inline void setDefaultValue(double dValue) {
+        m_defaultValue.setValue(dValue);
+    }
+    inline double defaultValue() const {
+        double default_value = m_defaultValue.getValue();
+        return m_pBehavior ? m_pBehavior->defaultValue(default_value) : default_value;
+    }
+
+  signals:
+    // Emitted when the ControlDoublePrivate value changes. pSetter is a
+    // pointer to the setter of the value (potentially NULL).
+    void valueChanged(double value, QObject* pSetter);
+
+  private:
+    ConfigKey m_key;
+    // Whether to ignore sets which would have no effect.
+    bool m_bIgnoreNops;
+
+    // Whether to track value changes with the stats framework.
+    bool m_bTrack;
+    QString m_trackKey;
+    int m_trackType;
+    int m_trackFlags;
+
+    // The control value.
+    ControlValueAtomic<double> m_value;
+    // The default control value.
+    ControlValueAtomic<double> m_defaultValue;
+
+    QAtomicPointer<ControlNumericBehavior> m_pBehavior;
+
+    // Hash of ControlDoublePrivate instantiations.
+    static QHash<ConfigKey,ControlDoublePrivate*> m_sqCOHash;
+    // Mutex guarding access to the ControlDoublePrivate hash.
+    static QMutex m_sqCOHashMutex;
+};
+
+
+#endif /* CONTROL_H */

=== added file 'mixxx/src/control/controlbehavior.cpp'
--- mixxx/src/control/controlbehavior.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/control/controlbehavior.cpp	2013-05-17 16:35:30 +0000
@@ -0,0 +1,194 @@
+#include "control/controlbehavior.h"
+#include "control/control.h"
+
+bool ControlNumericBehavior::setFilter(double* dValue) {
+    Q_UNUSED(dValue);
+    return true;
+}
+
+double ControlNumericBehavior::defaultValue(double dDefault) const {
+    return dDefault;
+}
+
+double ControlNumericBehavior::valueToWidgetParameter(double dValue) {
+    return dValue;
+}
+
+double ControlNumericBehavior::widgetParameterToValue(double dParam) {
+    return dParam;
+}
+
+double ControlNumericBehavior::valueToMidiParameter(double dValue) {
+    return dValue;
+}
+
+void ControlNumericBehavior::setValueFromMidiParameter(MidiOpCode o, double dParam,
+                                                       ControlDoublePrivate* pControl) {
+    Q_UNUSED(o);
+    pControl->set(dParam, NULL);
+}
+
+ControlPotmeterBehavior::ControlPotmeterBehavior(double dMinValue, double dMaxValue)
+        : m_dMinValue(dMinValue),
+          m_dMaxValue(dMaxValue),
+          m_dValueRange(m_dMaxValue - m_dMinValue),
+          m_dDefaultValue(m_dMinValue + 0.5 * m_dValueRange) {
+}
+
+ControlPotmeterBehavior::~ControlPotmeterBehavior() {
+}
+
+bool ControlPotmeterBehavior::setFilter(double* dValue) {
+    if (*dValue > m_dMaxValue) {
+        *dValue = m_dMaxValue;
+    } else if (*dValue < m_dMinValue) {
+        *dValue = m_dMinValue;
+    }
+    return true;
+}
+
+double ControlPotmeterBehavior::defaultValue(double dDefault) const {
+    Q_UNUSED(dDefault);
+    return m_dDefaultValue;
+}
+
+double ControlPotmeterBehavior::valueToWidgetParameter(double dValue) {
+    double dNorm = (dValue - m_dMinValue) / m_dValueRange;
+    return dNorm < 0.5 ? dNorm * 128.0 : dNorm * 126.0 + 1.0;
+}
+
+double ControlPotmeterBehavior::widgetParameterToValue(double dParam) {
+    double dNorm = dParam < 64 ? dParam / 128.0 : (dParam - 1.0) / 126.0;
+    return m_dMinValue + dNorm * m_dValueRange;
+}
+
+double ControlPotmeterBehavior::valueToMidiParameter(double dValue) {
+    return valueToWidgetParameter(dValue);
+}
+
+void ControlPotmeterBehavior::setValueFromMidiParameter(MidiOpCode o, double dParam,
+                                                        ControlDoublePrivate* pControl) {
+    Q_UNUSED(o);
+    pControl->set(widgetParameterToValue(dParam), NULL);
+}
+
+#define maxPosition 127
+#define minPosition 0
+#define middlePosition ((maxPosition-minPosition)/2)
+#define positionrange (maxPosition-minPosition)
+
+ControlLogpotmeterBehavior::ControlLogpotmeterBehavior(double dMaxValue)
+        : ControlPotmeterBehavior(0, dMaxValue) {
+    m_dB1 = log10(2.0) / middlePosition;
+    m_dB2 = log10(dMaxValue) / (maxPosition - middlePosition);
+}
+
+ControlLogpotmeterBehavior::~ControlLogpotmeterBehavior() {
+}
+
+double ControlLogpotmeterBehavior::defaultValue(double dDefault) {
+    Q_UNUSED(dDefault);
+    return 1.0;
+}
+
+double ControlLogpotmeterBehavior::valueToWidgetParameter(double dValue) {
+    if (dValue > 1.0) {
+        return log10(dValue) / m_dB2 + middlePosition;
+    } else {
+        return log10(dValue + 1.0) / m_dB1;
+    }
+}
+
+double ControlLogpotmeterBehavior::widgetParameterToValue(double dParam) {
+    if (dParam <= middlePosition) {
+        return pow(10.0, m_dB1 * dParam) - 1;
+    } else {
+        return pow(10.0, m_dB2 * (dParam - middlePosition));
+    }
+}
+
+ControlLinPotmeterBehavior::ControlLinPotmeterBehavior(double dMinValue, double dMaxValue)
+        : ControlPotmeterBehavior(dMinValue, dMaxValue) {
+}
+
+ControlLinPotmeterBehavior::~ControlLinPotmeterBehavior() {
+}
+
+double ControlLinPotmeterBehavior::valueToWidgetParameter(double dValue) {
+    double dNorm = (dValue - m_dMinValue) / m_dValueRange;
+    return math_min(dNorm * 128, 127);
+}
+
+double ControlLinPotmeterBehavior::widgetParameterToValue(double dParam) {
+    double dNorm = dParam / 128.0;
+    return m_dMinValue + dNorm * m_dValueRange;
+}
+
+double ControlTTRotaryBehavior::valueToWidgetParameter(double dValue) {
+    return dValue * 200.0 + 64;
+}
+
+double ControlTTRotaryBehavior::widgetParameterToValue(double dParam) {
+    // Non-linear scaling
+    double temp = ((dParam - 64.0) * (dParam - 64.0)) / 64.0;
+    if (dParam - 64 < 0) {
+        temp = -temp;
+    }
+    return temp;
+}
+
+// static
+const int ControlPushButtonBehavior::kPowerWindowTimeMillis = 300;
+
+ControlPushButtonBehavior::ControlPushButtonBehavior(ButtonMode buttonMode,
+                                                     int iNumStates)
+        : m_buttonMode(buttonMode),
+          m_iNumStates(iNumStates) {
+}
+
+void ControlPushButtonBehavior::setValueFromMidiParameter(
+    MidiOpCode o, double dParam, ControlDoublePrivate* pControl) {
+    // This block makes push-buttons act as power window buttons.
+    if (m_buttonMode == POWERWINDOW && m_iNumStates == 2) {
+        if (o == MIDI_NOTE_ON) {
+            if (dParam > 0.) {
+                double value = pControl->get();
+                pControl->set(!value, NULL);
+                m_pushTimer.setSingleShot(true);
+                m_pushTimer.start(kPowerWindowTimeMillis);
+            }
+        } else if (o == MIDI_NOTE_OFF) {
+            if (!m_pushTimer.isActive()) {
+                pControl->set(0.0, NULL);
+            }
+        }
+    } else if (m_buttonMode == TOGGLE) {
+        // This block makes push-buttons act as toggle buttons.
+        if (m_iNumStates > 2) { //multistate button
+            if (dParam > 0.) { //looking for NOTE_ON doesn't seem to work...
+                double value = pControl->get();
+                value++;
+                if (value >= m_iNumStates) {
+                    pControl->set(0, NULL);
+                } else {
+                    pControl->set(value, NULL);
+                }
+            }
+        } else {
+            if (o == MIDI_NOTE_ON) {
+                if (dParam > 0.) {
+                    double value = pControl->get();
+                    pControl->set(!value, NULL);
+                }
+            }
+        }
+    } else { //Not a toggle button (trigger only when button pushed)
+        if (o == MIDI_NOTE_ON) {
+            double value = pControl->get();
+            pControl->set(!value, NULL);
+        } else if (o == MIDI_NOTE_OFF) {
+            pControl->set(0.0, NULL);
+        }
+    }
+}
+

=== added file 'mixxx/src/control/controlbehavior.h'
--- mixxx/src/control/controlbehavior.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/control/controlbehavior.h	2013-05-17 16:35:30 +0000
@@ -0,0 +1,97 @@
+#ifndef CONTROLBEHAVIOR_H
+#define CONTROLBEHAVIOR_H
+
+#include <math.h>
+
+#include <QTimer>
+
+#include "controllers/midi/midimessage.h"
+#include "mathstuff.h"
+
+class ControlDoublePrivate;
+
+class ControlNumericBehavior {
+  public:
+    // Returns true if the set should occur. Mutates dValue if the value should
+    // be changed.
+    virtual bool setFilter(double* dValue);
+
+    virtual double defaultValue(double dDefault) const;
+    virtual double valueToWidgetParameter(double dValue);
+    virtual double widgetParameterToValue(double dParam);
+    virtual double valueToMidiParameter(double dValue);
+    virtual void setValueFromMidiParameter(MidiOpCode o, double dParam,
+                                           ControlDoublePrivate* pControl);
+};
+
+class ControlPotmeterBehavior : public ControlNumericBehavior {
+  public:
+    ControlPotmeterBehavior(double dMinValue, double dMaxValue);
+    virtual ~ControlPotmeterBehavior();
+
+    virtual bool setFilter(double* dValue);
+    virtual double defaultValue(double dDefault) const;
+    virtual double valueToWidgetParameter(double dValue);
+    virtual double widgetParameterToValue(double dParam);
+    virtual double valueToMidiParameter(double dValue);
+    virtual void setValueFromMidiParameter(MidiOpCode o, double dParam,
+                                           ControlDoublePrivate* pControl);
+
+  protected:
+    double m_dMinValue;
+    double m_dMaxValue;
+    double m_dValueRange;
+    double m_dDefaultValue;
+};
+
+class ControlLogpotmeterBehavior : public ControlPotmeterBehavior {
+  public:
+    ControlLogpotmeterBehavior(double dMaxValue);
+    virtual ~ControlLogpotmeterBehavior();
+
+    virtual double defaultValue(double dDefault);
+    virtual double valueToWidgetParameter(double dValue);
+    virtual double widgetParameterToValue(double dParam);
+
+  protected:
+    double m_dB1, m_dB2;
+};
+
+class ControlLinPotmeterBehavior : public ControlPotmeterBehavior {
+  public:
+    ControlLinPotmeterBehavior(double dMinValue, double dMaxValue);
+    virtual ~ControlLinPotmeterBehavior();
+
+    virtual double valueToWidgetParameter(double dValue);
+    virtual double widgetParameterToValue(double dParam);
+};
+
+class ControlTTRotaryBehavior : public ControlNumericBehavior {
+  public:
+    virtual double valueToWidgetParameter(double dValue);
+    virtual double widgetParameterToValue(double dParam);
+};
+
+class ControlPushButtonBehavior : public ControlNumericBehavior {
+  public:
+    static const int kPowerWindowTimeMillis;
+
+    // TODO(XXX) Duplicated from ControlPushButton. It's complicated and
+    // annoying to share them so I just copied them.
+    enum ButtonMode {
+         PUSH = 0,
+         TOGGLE,
+         POWERWINDOW
+    };
+
+    ControlPushButtonBehavior(ButtonMode buttonMode, int iNumStates);
+    virtual void setValueFromMidiParameter(MidiOpCode o, double dParam,
+                                           ControlDoublePrivate* pControl);
+
+  private:
+    ButtonMode m_buttonMode;
+    int m_iNumStates;
+    QTimer m_pushTimer;
+};
+
+#endif /* CONTROLBEHAVIOR_H */

=== added file 'mixxx/src/control/controlvalue.h'
--- mixxx/src/control/controlvalue.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/control/controlvalue.h	2013-05-17 16:35:30 +0000
@@ -0,0 +1,157 @@
+#ifndef CONTROLVALUE_H
+#define CONTROLVALUE_H
+
+#include <limits>
+
+#include <QAtomicInt>
+#include <QObject>
+
+// for look free access, this value has to be >= the number of value using threads
+// value must be a fraction of an integer
+const int cRingSize = 8;
+// there are basicly unlimited readers allowed at each ring element
+// but we have to count them so max() is just fine.
+const int cReaderSlotCnt = std::numeric_limits<int>::max();
+
+// A single instance of a value of type T along with an atomic integer which
+// tracks the current number of readers or writers of the slot. The value
+// m_readerSlots starts at cReaderSlotCnt and counts down to 0. If the value is
+// 0 or less then reads to the value fail because there are either too many
+// readers or a write is occurring. A write to the value will fail if
+// m_readerSlots is not equal to cReaderSlotCnt (e.g. there is an active
+// reader).
+template<typename T>
+class ControlRingValue {
+  public:
+    ControlRingValue()
+        : m_value(T()),
+          m_readerSlots(cReaderSlotCnt) {
+    }
+
+    bool tryGet(T* value) const {
+        // Read while consuming one readerSlot
+        bool hasSlot = (m_readerSlots.fetchAndAddAcquire(-1) > 0);
+        if (hasSlot) {
+            *value = m_value;
+        }
+        (void)m_readerSlots.fetchAndAddRelease(1);
+        return hasSlot;
+    }
+
+    bool trySet(const T& value) {
+        // try to lock this element entirely for reading
+        if (m_readerSlots.testAndSetAcquire(cReaderSlotCnt, 0)) {
+            m_value = value;
+            m_readerSlots.fetchAndAddRelease(cReaderSlotCnt);
+            return true;
+        }
+        return false;
+   }
+
+  private:
+    T m_value;
+    mutable QAtomicInt m_readerSlots;
+};
+
+// Ring buffer based implementation for all Types sizeof(T) > sizeof(void*)
+
+// An implementation of ControlValueAtomicBase for non-atomic types T. Uses a
+// ring-buffer of ControlRingValues and a read pointer and write pointer to
+// provide getValue()/setValue() methods which *sacrifice perfect consistency*
+// for the benefit of wait-free read/write access to a value.
+template<typename T, bool ATOMIC = false>
+class ControlValueAtomicBase {
+  public:
+    inline T getValue() const {
+        T value = T();
+        unsigned int index = (unsigned int)m_readIndex
+                % (cRingSize);
+        while (m_ring[index].tryGet(&value) == false) {
+            // We are here if
+            // 1) there are more then cReaderSlotCnt reader (get) reading the same value or
+            // 2) the formerly current value is locked by a writer
+            // Case 1 does not happen because we have enough (0x7fffffff) reader slots.
+            // Case 2 happens when the a reader is delayed after reading the
+            // m_currentIndex and in the mean while a reader locks the formaly current value
+            // because it has written cRingSize times. Reading the less recent value will fix
+            // it because it is now actualy the current value.
+            index = (index - 1) % (cRingSize);
+        }
+        return value;
+    }
+
+    inline void setValue(const T& value) {
+        // Test if we can read atomic
+        // This test is const and will be mad only at compile time
+        unsigned int index;
+        do {
+            index = (unsigned int)m_writeIndex.fetchAndAddAcquire(1)
+                    % (cRingSize);
+            // This will be repeated if the value is locked
+            // 1) by an other writer writing at the same time or
+            // 2) a delayed reader is still blocking the formerly current value
+            // In both cases writing to the next value will fix it.
+        } while (!m_ring[index].trySet(value));
+        m_readIndex = (int)index;
+    }
+
+  protected:
+    ControlValueAtomicBase()
+        : m_readIndex(0),
+          m_writeIndex(1) {
+        Q_ASSERT((std::numeric_limits<unsigned int>::max() % cRingSize) == (cRingSize - 1));
+    }
+
+  private:
+    // In worst case, each reader can consume a reader slot from a different ring element.
+    // In this case there is still one ring element available for writing.
+    ControlRingValue<T> m_ring[cRingSize];
+    QAtomicInt m_readIndex;
+    QAtomicInt m_writeIndex;
+};
+
+// Specialized template for types that are deemed to be atomic on the target
+// architecture. Instead of using a read/write ring to guarantee atomicity,
+// direct assignment/read of an aligned member variable is used.
+template<typename T>
+class ControlValueAtomicBase<T, true> {
+  public:
+    inline T getValue() const {
+        return m_value;
+    }
+
+    inline void setValue(const T& value) {
+        m_value = value;
+    }
+
+  protected:
+    ControlValueAtomicBase()
+            : m_value(T()) {
+    }
+
+  private:
+#if defined(__GNUC__)
+    T m_value __attribute__ ((aligned(sizeof(void*))));
+#elif defined(_MSC_VER)
+    T __declspec(align(sizeof(void*))) m_value;
+#else
+    T m_value;
+#endif
+};
+
+// ControlValueAtomic is a wrapper around ControlValueAtomicBase which uses the
+// sizeof(T) to determine which underlying implementation of
+// ControlValueAtomicBase to use. For types where sizeof(T) <= sizeof(void*),
+// the specialized implementation of ControlValueAtomicBase for types that are
+// atomic on the architecture is used.
+template<typename T>
+class ControlValueAtomic
+    : public ControlValueAtomicBase<T, sizeof(T) <= sizeof(void*)> {
+  public:
+
+    ControlValueAtomic()
+        : ControlValueAtomicBase<T, sizeof(T) <= sizeof(void*)>() {
+    }
+};
+
+#endif /* CONTROLVALUE_H */

=== removed file 'mixxx/src/controlbeat.cpp'
--- mixxx/src/controlbeat.cpp	2012-11-20 00:40:18 +0000
+++ mixxx/src/controlbeat.cpp	1970-01-01 00:00:00 +0000
@@ -1,85 +0,0 @@
-/***************************************************************************
-                          controlbeat.cpp  -  description
-                             -------------------
-    begin                : Mon Apr 7 2003
-    copyright            : (C) 2003 by Tue & Ken Haste Andersen
-    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 "controlbeat.h"
-
-ControlBeat::ControlBeat(ConfigKey key, bool bMidiSimulateLatching) : ControlObject(key)
-{
-    m_bMidiSimulateLatching = bMidiSimulateLatching;
-    m_dValue = 0.;
-    time.start();
-    m_bPressed = false;
-    m_iValidPresses = 0;
-
-    // Filter buffer
-    buffer = new CSAMPLE[filterLength];
-    for (int i=0; i<filterLength; i++)
-        buffer[i] = 0.;
-}
-
-ControlBeat::~ControlBeat()
-{
-    delete [] buffer;
-}
-
-void ControlBeat::setValueFromMidi(MidiOpCode o, double v)
-{
-    Q_UNUSED(o);
-    Q_UNUSED(v);
-    if (!m_bPressed || !m_bMidiSimulateLatching)
-    {
-        beatTap();
-        m_bPressed = true;
-    }
-    else
-        m_bPressed = false;
-}
-
-void ControlBeat::setValueFromThread(double dValue) {
-    if (dValue > 0) {
-        beatTap();
-    }
-}
-
-void ControlBeat::beatTap()
-{
-    int elapsed = time.restart();
-
-    if (elapsed <= maxInterval) {
-        // Move back in filter one sample
-        for (int i = filterLength-1; i > 0; i--)
-            buffer[i] = buffer[i-1];
-
-        buffer[0] = 1000.*(60./elapsed);
-        if (buffer[0] > maxBPM)
-            buffer[0] = maxBPM;
-
-        m_iValidPresses++;
-        if (m_iValidPresses > filterLength)
-            m_iValidPresses = filterLength;
-
-        double temp = 0.;
-        for (int i = 0; i < m_iValidPresses; ++i)
-            temp += buffer[i];
-        temp /= m_iValidPresses;
-        m_dValue = temp;
-
-        emit(valueChanged(m_dValue));
-    } else {
-        m_iValidPresses = 0;
-    }
-}

=== removed file 'mixxx/src/controlbeat.h'
--- mixxx/src/controlbeat.h	2012-03-17 17:42:44 +0000
+++ mixxx/src/controlbeat.h	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-/***************************************************************************
-                          controlbeat.h  -  description
-                             -------------------
-    begin                : Mon Apr 7 2003
-    copyright            : (C) 2003 by Tue & Ken Haste Andersen
-    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 CONTROLBEAT_H
-#define CONTROLBEAT_H
-
-#include "controlobject.h"
-#include "configobject.h"
-#include "defs.h"
-#include <qdatetime.h>
-
-/**
-  * Takes impulses as input, and convert it to a BPM measure.
-  *
-  *@author Tue & Ken Haste Andersen
-  */
-
-/** Minimum allowed Beat per minute (BPM) */
-const int minBPM = 30;
-/** Maximum allowed bpm */
-const int maxBPM = 240;
-/** Maximum allowed interval between beats in milli seconds (calculated from minBPM) */
-const int maxInterval = (int)(1000.*(60./(CSAMPLE)minBPM));
-/** Filter length */
-const int filterLength = 5;
-
-class ControlBeat : public ControlObject {
-  public:
-    ControlBeat(ConfigKey key, bool bMidiSimulateLatching=false);
-    virtual ~ControlBeat();
-
-  protected:
-    void setValueFromMidi(MidiOpCode o, double v);
-    void setValueFromThread(double dValue);
-  private:
-    void beatTap();
-
-    QTime time;
-    CSAMPLE *buffer;
-    bool m_bMidiSimulateLatching;
-    bool m_bPressed;
-    int m_iValidPresses;
-};
-
-#endif

=== modified file 'mixxx/src/controllers/controller.h'
--- mixxx/src/controllers/controller.h	2013-02-09 05:21:42 +0000
+++ mixxx/src/controllers/controller.h	2013-05-17 16:35:30 +0000
@@ -72,8 +72,6 @@
     // Emitted when a new preset is loaded. pPreset is a /clone/ of the loaded
     // preset, not a pointer to the preset itself.
     void presetLoaded(ControllerPresetPointer pPreset);
-    // Emitted when the MIDI controller requests that the control system sync.
-    void syncControlSystem();
 
   // Making these slots protected/private ensures that other parts of Mixxx can
   // only signal them which allows us to use no locks.

=== modified file 'mixxx/src/controllers/controllerengine.cpp'
--- mixxx/src/controllers/controllerengine.cpp	2013-04-27 22:06:33 +0000
+++ mixxx/src/controllers/controllerengine.cpp	2013-05-17 16:35:30 +0000
@@ -640,11 +640,11 @@
 
     ControlObjectThread *cot = getControlObjectThread(group, name);
 
-    if (cot != NULL && !m_st.ignore(cot->getControlObject(), newValue)) {
-        cot->slotSet(newValue);
-        // We call emitValueChanged so that script functions connected to this
-        // control will get updates.
-        cot->emitValueChanged();
+    if (cot != NULL) {
+        ControlObject* pControl = ControlObject::getControl(cot->getKey());
+        if (pControl && !m_st.ignore(pControl, newValue)) {
+            cot->slotSet(newValue);
+        }
     }
 }
 
@@ -815,12 +815,7 @@
         return;
     }
 
-    ControlObject* pSenderCO = senderCOT->getControlObject();
-    if (pSenderCO == NULL) {
-        qWarning() << "ControllerEngine::slotValueChanged() The sender's CO is NULL.";
-        return;
-    }
-    ConfigKey key = pSenderCO->getKey();
+    ConfigKey key = senderCOT->getKey();
 
     //qDebug() << "[Controller]: SlotValueChanged" << key.group << key.item;
 

=== modified file 'mixxx/src/controllers/controllermanager.cpp'
--- mixxx/src/controllers/controllermanager.cpp	2013-02-09 05:21:42 +0000
+++ mixxx/src/controllers/controllermanager.cpp	2013-05-17 16:35:30 +0000
@@ -288,8 +288,6 @@
     if (pController->isOpen()) {
         pController->close();
     }
-    connect(pController, SIGNAL(syncControlSystem()),
-            this, SIGNAL(syncControlSystem()));
     int result = pController->open();
     maybeStartOrStopPolling();
 
@@ -308,8 +306,6 @@
     if (!pController) {
         return;
     }
-    disconnect(pController, SIGNAL(syncControlSystem()),
-               this, SIGNAL(syncControlSystem()));
     pController->close();
     maybeStartOrStopPolling();
     // Update configuration to reflect controller is disabled.

=== modified file 'mixxx/src/controllers/controllermanager.h'
--- mixxx/src/controllers/controllermanager.h	2013-02-09 05:21:42 +0000
+++ mixxx/src/controllers/controllermanager.h	2013-05-17 16:35:30 +0000
@@ -42,7 +42,6 @@
     void requestSetUpDevices();
     void requestShutdown();
     void requestSave(bool onlyActive);
-    void syncControlSystem();
 
   public slots:
     void updateControllerList();

=== modified file 'mixxx/src/controllers/midi/midicontroller.cpp'
--- mixxx/src/controllers/midi/midicontroller.cpp	2013-05-15 05:27:41 +0000
+++ mixxx/src/controllers/midi/midicontroller.cpp	2013-05-17 16:35:30 +0000
@@ -312,8 +312,6 @@
         return;
     }
 
-    double currMixxxControlValue = p->GetMidiValue();
-
     double newValue = value;
 
     //qDebug() << "MIDI Options" << QString::number(options.all, 2).rightJustified(16,'0');
@@ -323,14 +321,11 @@
         int ivalue;
         ivalue = (value << 7) | control;
 
-        currMixxxControlValue = p->get();
-
         // Range is 0x0000..0x3FFF center @ 0x2000, i.e. 0..16383 center @ 8192
         if (options.invert) {
             newValue = 0x2000-ivalue;
             if (newValue < 0) newValue--;
-        }
-        else {
+        } else {
             newValue = ivalue-0x2000;
             if (newValue > 0) newValue++;
         }
@@ -339,6 +334,7 @@
 
         // computeValue not (yet) done on pitch messages because it all assumes 7-bit numbers
     } else {
+        double currMixxxControlValue = p->getValueToMidi();
         newValue = computeValue(options, currMixxxControlValue, value);
     }
 
@@ -360,22 +356,15 @@
                 return;
             }
         }
-        p->queueFromThread(newValue);
-    }
-    else {
+        p->setValueFromThread(newValue, NULL);
+    } else {
         if (options.soft_takeover) {
             if (m_st.ignore(p, newValue, true)) {
                 return;
             }
         }
-        p->queueFromMidi(static_cast<MidiOpCode>(opCode), newValue);
+        p->setValueFromMidi(static_cast<MidiOpCode>(opCode), newValue);
     }
-
-    // If we got here then we queued a message for the control system. In the
-    // interest of quickly processing this, we request a sync. Since we are
-    // running in the controller thread, we broadcast the signal which is
-    // proxied to the main thread and handled there.
-    emit(syncControlSystem());
 }
 
 double MidiController::computeValue(MidiOptions options, double _prevmidivalue, double _newmidivalue) {

=== modified file 'mixxx/src/controllers/midi/midioutputhandler.cpp'
--- mixxx/src/controllers/midi/midioutputhandler.cpp	2012-09-26 00:57:08 +0000
+++ mixxx/src/controllers/midi/midioutputhandler.cpp	2013-05-17 16:35:30 +0000
@@ -6,10 +6,11 @@
  *
  */
 
+#include <QtDebug>
+
 #include "controllers/midi/midioutputhandler.h"
 #include "controllers/midi/midicontroller.h"
-
-#include <QDebug>
+#include "controlobject.h"
 
 MidiOutputHandler::MidiOutputHandler(QString group, QString key,
                                      MidiController *controller,
@@ -25,34 +26,24 @@
           m_on(on),
           m_off(off),
           m_lastVal(0) {
+    connect(&m_cobj, SIGNAL(valueChanged(double)),
+            this, SLOT(controlChanged(double)));
 }
 
 MidiOutputHandler::~MidiOutputHandler() {
-    if (m_cobj != NULL) {
-        ConfigKey cKey = m_cobj->getKey();
-        if (m_pController->debugging()) {
-            qDebug() << QString("Destroying static MIDI output handler on %1 for %2,%3")
-                    .arg(m_pController->getName(), cKey.group, cKey.item);
-        }
+    ConfigKey cKey = m_cobj.getKey();
+    if (m_pController->debugging()) {
+        qDebug() << QString("Destroying static MIDI output handler on %1 for %2,%3")
+                .arg(m_pController->getName(), cKey.group, cKey.item);
     }
 }
 
 bool MidiOutputHandler::validate() {
-    if (m_cobj == NULL) {
-        return false;
-    }
-    connect(m_cobj, SIGNAL(valueChangedFromEngine(double)),
-            this, SLOT(controlChanged(double)));
-    connect(m_cobj, SIGNAL(valueChanged(double)),
-            this, SLOT(controlChanged(double)));
-    return true;
+    return m_cobj.valid();
 }
 
 void MidiOutputHandler::update() {
-    if (m_cobj == NULL) {
-        return;
-    }
-    controlChanged(m_cobj->get());
+    controlChanged(m_cobj.get());
 }
 
 void MidiOutputHandler::controlChanged(double value) {

=== modified file 'mixxx/src/controllers/midi/midioutputhandler.h'
--- mixxx/src/controllers/midi/midioutputhandler.h	2012-04-24 05:51:32 +0000
+++ mixxx/src/controllers/midi/midioutputhandler.h	2013-05-17 16:35:30 +0000
@@ -11,7 +11,7 @@
 #ifndef MIDIOUTPUTHANDLER_H
 #define MIDIOUTPUTHANDLER_H
 
-#include "controlobject.h"
+#include "controlobjectthread.h"
 
 class MidiController;   // forward declaration
 
@@ -32,7 +32,7 @@
 
   private:
     MidiController* m_pController;
-    ControlObject* m_cobj;
+    ControlObjectThread m_cobj;
     float m_min;
     float m_max;
     unsigned char m_status;

=== modified file 'mixxx/src/controllers/softtakeover.cpp'
--- mixxx/src/controllers/softtakeover.cpp	2013-04-27 22:06:33 +0000
+++ mixxx/src/controllers/softtakeover.cpp	2013-05-17 16:35:30 +0000
@@ -79,7 +79,7 @@
             threshold = scaleFactor*(threshold/128.0f);
         }
 
-        double currentValue = midiVal ? control->GetMidiValue() : control->get();
+        double currentValue = midiVal ? control->getValueToMidi() : control->get();
         double difference = currentValue - newValue;
         double prevDiff = 0;
         bool sameSide = false;

=== modified file 'mixxx/src/controllinpotmeter.cpp'
--- mixxx/src/controllinpotmeter.cpp	2012-12-22 14:07:45 +0000
+++ mixxx/src/controllinpotmeter.cpp	2013-05-17 16:35:30 +0000
@@ -1,34 +1,15 @@
 #include "controllinpotmeter.h"
 #include "defs.h"
 
-
 // This control has a linear link between the m_dValue and the Midi Value
 // limitation: m_dMaxValue represents the midi value of 128 and is never reached
 ControlLinPotmeter::ControlLinPotmeter(ConfigKey key, double dMinValue, double dMaxValue) :
     ControlPotmeter(key, dMinValue, dMaxValue) {
-
-}
-
-double ControlLinPotmeter::getValueToWidget(double dValue) {
-    double out = (dValue - m_dMinValue) / m_dValueRange;
-    return math_min(out * 128, 127);
-}
-
-double ControlLinPotmeter::GetMidiValue() {
-    double out = (m_dValue-m_dMinValue)/m_dValueRange;
-    return math_min(out * 128, 127);
-}
-
-double ControlLinPotmeter::getValueFromWidget(double dValue) {
-    double out = dValue / 128;
-    return m_dMinValue + out * m_dValueRange;
-}
-
-void ControlLinPotmeter::setValueFromMidi(MidiOpCode o, double v) {
-    Q_UNUSED(o);
-    double out = v / 128;
-    m_dValue = m_dMinValue + out * m_dValueRange;
-    emit(valueChanged(m_dValue));
+    if (m_pControl) {
+        ControlNumericBehavior* pOldBehavior = m_pControl->setBehavior(
+            new ControlLinPotmeterBehavior(dMinValue, dMaxValue));
+        delete pOldBehavior;
+    }
 }
 
 

=== modified file 'mixxx/src/controllinpotmeter.h'
--- mixxx/src/controllinpotmeter.h	2012-12-22 14:07:45 +0000
+++ mixxx/src/controllinpotmeter.h	2013-05-17 16:35:30 +0000
@@ -3,19 +3,10 @@
 
 #include "controlpotmeter.h"
 
-class ControlLinPotmeter : public ControlPotmeter
-{
+class ControlLinPotmeter : public ControlPotmeter {
     Q_OBJECT
   public:
-
     ControlLinPotmeter(ConfigKey key, double dMinValue=0.0, double dMaxValue=1.0);
-
-    double getValueToWidget(double dValue);
-    double GetMidiValue();
-    double getValueFromWidget(double dValue);
-
-  protected:
-    void setValueFromMidi(MidiOpCode o, double v);
 };
 
 #endif // CONTROLLINPOTMETER_H

=== modified file 'mixxx/src/controllogpotmeter.cpp'
--- mixxx/src/controllogpotmeter.cpp	2012-04-27 07:47:21 +0000
+++ mixxx/src/controllogpotmeter.cpp	2013-05-17 16:35:30 +0000
@@ -15,14 +15,8 @@
 *                                                                         *
 ***************************************************************************/
 
-#include <math.h>
 #include "controllogpotmeter.h"
 
-#define maxPosition 127
-#define minPosition 0
-#define middlePosition ((maxPosition-minPosition)/2)
-#define positionrange (maxPosition-minPosition)
-
 /* -------- ------------------------------------------------------
    Purpose: Creates a new logarithmic potmeter, where the value is
             given by:
@@ -38,86 +32,16 @@
             midino - number of the midi controller.
             midicontroller - pointer to the midi controller.
    -------- ------------------------------------------------------ */
-ControlLogpotmeter::ControlLogpotmeter(ConfigKey key, double dMaxValue) : ControlPotmeter(key)
-{
-    m_dMinValue = 0.;
-    m_dMaxValue = dMaxValue;
-
-    if (m_dMaxValue==1.)
-    {
-        m_bTwoState = false;
-
-        m_fB1 = log10(2.)/maxPosition;
-    }
-    else
-    {
-        m_bTwoState = true;
-
-        m_fB1 = log10(2.)/middlePosition;
-        m_fB2 = log10(dMaxValue)/(maxPosition-middlePosition);
-    }
-
-    m_dValueRange = m_dMaxValue-m_dMinValue;
-
-    m_dValue = 1.0;
-    m_dDefaultValue = 1.0;
-}
-
-double ControlLogpotmeter::getValueFromWidget(double dValue)
-{
-    double dResult = 0;
-
-    // Calculate the value linearly:
-    if (!m_bTwoState)
-    {
-        dResult = pow(10., (double)(m_fB1*dValue)) - 1;
-    }
-    else
-    {
-        if (dValue <= middlePosition)
-            dResult = pow(10., m_fB1*dValue) - 1;
-        else
-            dResult = pow(10., m_fB2*(dValue - middlePosition));
-    }
-
-    //qDebug() << "Midi: " << dValue << " ValueFromWidget : " << m_dValue;
-    return dResult;
-}
-
-double ControlLogpotmeter::getValueToWidget(double dValue)
-{
-    double pos;
-
-    if (!m_bTwoState)
-    {
-        pos = log10(dValue+1)/m_fB1;
-    }
-    else
-    {
-        if (m_dValue>1.)
-            pos = log10(dValue)/m_fB2 + middlePosition;
-        else
-            pos = log10(dValue+1)/m_fB1;
-    }
-    //qDebug() << "GetValueToWidget : " << pos;
-    return pos;
-}
-
-double ControlLogpotmeter::GetMidiValue()
-{
-    double midival = 0.;
-
-    midival = getValueToWidget(m_dValue);
-    //    midival = 127.*(midival-m_dMinValue)/m_dValueRange
-    //qDebug() << "GetMidiValue : " << midival;
-    return midival;
-}
-
-void ControlLogpotmeter::setValueFromMidi(MidiOpCode o, double v) {
-    Q_UNUSED(o);
-  //    m_dValue = m_dMinValue + (v/127.)*m_dValueRange;
-    m_dValue = getValueFromWidget(v);
-    //    qDebug() << "SetValueFromMidiValue : " << m_dValue;
-    emit(valueChanged(m_dValue));
+ControlLogpotmeter::ControlLogpotmeter(ConfigKey key, double dMaxValue)
+    : ControlPotmeter(key, 0, dMaxValue) {
+    // Override ControlPotmeters default value of 0.5
+    setDefaultValue(1.0);
+    set(1.0);
+
+    if (m_pControl) {
+        ControlNumericBehavior* pOldBehavior = m_pControl->setBehavior(
+            new ControlLogpotmeterBehavior(dMaxValue));
+        delete pOldBehavior;
+    }
 }
 

=== modified file 'mixxx/src/controllogpotmeter.h'
--- mixxx/src/controllogpotmeter.h	2012-03-17 17:42:44 +0000
+++ mixxx/src/controllogpotmeter.h	2013-05-17 16:35:30 +0000
@@ -3,7 +3,7 @@
                              -------------------
     begin                : Wed Feb 20 2002
     copyright            : (C) 2002 by Tue and Ken Haste Andersen
-    email                : 
+    email                :
  ***************************************************************************/
 
 /***************************************************************************
@@ -26,28 +26,10 @@
  *@author Tue and Ken Haste Andersen
  */
 
-class ControlLogpotmeter : public ControlPotmeter
-{
+class ControlLogpotmeter : public ControlPotmeter {
     Q_OBJECT
-public:
+  public:
     ControlLogpotmeter(ConfigKey key, double dMaxValue=5.);
-    
-    double getValueFromWidget(double dValue);
-    double getValueToWidget(double dValue);
-
-    double GetMidiValue();
-    
-    void setValueFromMidi(MidiOpCode o, double v);
-
-protected:
-
-    // This is true, if the log potmeter is divided into two states, one from 0 to 1, and
-    // the second from 1 to m_dMaxValue. Two states is often used with knobs where the first
-    // half rotation is used to control a value between 0 and 1, and the second half between
-    // 1 and some bigger value.
-    bool m_bTwoState;
-    
-    double m_fB1, m_fB2;
 };
 
 #endif

=== removed file 'mixxx/src/controlnull.cpp'
--- mixxx/src/controlnull.cpp	2007-09-09 22:52:24 +0000
+++ mixxx/src/controlnull.cpp	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-/***************************************************************************
-                          controlnull.cpp  -  description
-                             -------------------
-    begin                : Sat Jun 15 2002
-    copyright            : (C) 2002 by Tue & Ken Haste Andersen
-    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 "controlnull.h"
-
-ControlNull::ControlNull() : ControlObject()
-{
-}
-
-ControlNull::~ControlNull()
-{
-}
-

=== removed file 'mixxx/src/controlnull.h'
--- mixxx/src/controlnull.h	2004-10-01 08:18:11 +0000
+++ mixxx/src/controlnull.h	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-/***************************************************************************
-                          controlnull.h  -  description
-                             -------------------
-    begin                : Sat Jun 15 2002
-    copyright            : (C) 2002 by Tue & Ken Haste Andersen
-    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 CONTROLNULL_H
-#define CONTROLNULL_H
-
-#include "controlobject.h"
-
-/**
-  *@author Tue & Ken Haste Andersen
-  */
-
-class ControlNull : public ControlObject  {
-    Q_OBJECT
-public:
-    ControlNull();
-    ~ControlNull();
-};
-
-#endif

=== modified file 'mixxx/src/controlobject.cpp'
--- mixxx/src/controlobject.cpp	2012-12-31 23:06:59 +0000
+++ mixxx/src/controlobject.cpp	2013-05-17 16:35:30 +0000
@@ -22,6 +22,7 @@
 
 #include "controlobject.h"
 #include "controlevent.h"
+#include "control/control.h"
 #include "util/stat.h"
 #include "util/timer.h"
 
@@ -29,110 +30,62 @@
 QHash<ConfigKey,ControlObject*> ControlObject::m_sqCOHash;
 QMutex ControlObject::m_sqCOHashMutex;
 
-QMutex ControlObject::m_sqQueueMutexMidi;
-QMutex ControlObject::m_sqQueueMutexThread;
-QMutex ControlObject::m_sqQueueMutexChanges;
-QQueue<QueueObjectMidi*> ControlObject::m_sqQueueMidi;
-QQueue<QueueObjectThread*> ControlObject::m_sqQueueThread;
-QQueue<ControlObject*> ControlObject::m_sqQueueChanges;
 
 ControlObject::ControlObject()
-        : m_dValue(0),
-          m_dDefaultValue(0),
-          m_bIgnoreNops(true) {
-}
-
-ControlObject::ControlObject(ConfigKey key, bool bIgnoreNops, bool track)
-        : m_dValue(0),
-          m_dDefaultValue(0),
-          m_key(key),
-          m_bIgnoreNops(bIgnoreNops),
-          m_bTrack(track),
-          m_trackKey("control " + m_key.group + "," + m_key.item),
-          m_trackType(Stat::UNSPECIFIED),
-          m_trackFlags(Stat::COUNT | Stat::SUM | Stat::AVERAGE |
-                       Stat::SAMPLE_VARIANCE | Stat::MIN | Stat::MAX) {
-    m_sqCOHashMutex.lock();
-    m_sqCOHash.insert(m_key, this);
-    m_sqCOHashMutex.unlock();
-
-    if (m_bTrack) {
-        // TODO(rryan): Make configurable.
-        Stat::track(m_trackKey, static_cast<Stat::StatType>(m_trackType),
-                    static_cast<Stat::ComputeFlags>(m_trackFlags), m_dValue);
-    }
-}
-
-ControlObject::ControlObject(const QString& group, const QString& item, bool bIgnoreNops)
-        : m_dValue(0),
-          m_dDefaultValue(0),
-          m_key(group, item),
-          m_bIgnoreNops(bIgnoreNops) {
-    m_sqCOHashMutex.lock();
-    m_sqCOHash.insert(m_key, this);
-    m_sqCOHashMutex.unlock();
+        : m_pControl(NULL) {
+}
+
+ControlObject::ControlObject(ConfigKey key, bool bIgnoreNops, bool bTrack)
+        : m_pControl(NULL) {
+    initialize(key, bIgnoreNops, bTrack);
+}
+
+ControlObject::ControlObject(const QString& group, const QString& item,
+                             bool bIgnoreNops, bool bTrack)
+        : m_pControl(NULL) {
+    initialize(ConfigKey(group, item), bIgnoreNops, bTrack);
 }
 
 ControlObject::~ControlObject() {
     m_sqCOHashMutex.lock();
     m_sqCOHash.remove(m_key);
     m_sqCOHashMutex.unlock();
-
-    ControlObjectThread * obj;
-    m_qProxyListMutex.lock();
-    QListIterator<ControlObjectThread*> it(m_qProxyList);
-    while (it.hasNext())
-    {
-        obj = it.next();
-        obj->slotParentDead();
-    }
-    m_qProxyListMutex.unlock();
-
-
-    m_sqQueueMutexThread.lock();
-    QMutableListIterator<QueueObjectThread*> tit(m_sqQueueThread);
-    while (tit.hasNext()) {
-        QueueObjectThread* tobj = tit.next();
-        if (tobj->pControlObject == this) {
-            tit.remove();
-            delete tobj;
-        }
-    }
-    m_sqQueueMutexThread.unlock();
-
-    m_sqQueueMutexMidi.lock();
-    QMutableListIterator<QueueObjectMidi*> mit(m_sqQueueMidi);
-    while (mit.hasNext()) {
-        QueueObjectMidi* mobj = mit.next();
-        if (mobj->pControlObject == this) {
-            mit.remove();
-            delete mobj;
-        }
-    }
-    m_sqQueueMutexMidi.unlock();
-
-    // Remove this control object from the changes queue, since we're being
-    // deleted.
-    m_sqQueueMutexChanges.lock();
-    m_sqQueueChanges.removeAll(this);
-    m_sqQueueMutexChanges.unlock();
-
-}
-
+}
+
+void ControlObject::initialize(ConfigKey key, bool bIgnoreNops, bool bTrack) {
+    m_key = key;
+    m_pControl = ControlDoublePrivate::getControl(m_key, true, bIgnoreNops, bTrack);
+    connect(m_pControl, SIGNAL(valueChanged(double, QObject*)),
+            this, SLOT(privateValueChanged(double, QObject*)),
+            Qt::DirectConnection);
+
+    m_sqCOHashMutex.lock();
+    m_sqCOHash.insert(m_key, this);
+    m_sqCOHashMutex.unlock();
+}
+
+void ControlObject::privateValueChanged(double dValue, QObject* pSetter) {
+    // Only emit valueChanged() if we did not originate this change.
+    if (pSetter != this) {
+        emit(valueChanged(dValue));
+    } else {
+        emit(valueChangedFromEngine(dValue));
+    }
+}
+
+/*
 bool ControlObject::connectControls(ConfigKey src, ConfigKey dest)
 {
     // Find src and dest objects
     ControlObject * pSrc = getControl(src);
     ControlObject * pDest = getControl(dest);
 
-    if (pSrc && pDest)
-    {
+    if (pSrc && pDest) {
         connect(pSrc, SIGNAL(valueChanged(double)), pDest, SLOT(set(double)));
-        connect(pSrc, SIGNAL(valueChangedFromEngine(double)), pDest, SLOT(set(double)));
         return true;
+    } else {
+        return false;
     }
-    else
-        return false;
 }
 
 bool ControlObject::disconnectControl(ConfigKey key)
@@ -148,42 +101,9 @@
     else
         return false;
 }
-
-void ControlObject::addProxy(ControlObjectThread * pControlObjectThread)
-{
-    m_qProxyListMutex.lock();
-    m_qProxyList.append(pControlObjectThread);
-    m_qProxyListMutex.unlock();
-}
-
-void ControlObject::removeProxy(ControlObjectThread * pControlObjectThread) {
-    m_qProxyListMutex.lock();
-    m_qProxyList.removeAll(pControlObjectThread);
-    m_qProxyListMutex.unlock();
-}
-
-bool ControlObject::updateProxies(ControlObjectThread * pProxyNoUpdate)
-{
-    ControlObjectThread * obj;
-    bool bUpdateSuccess = true;
-    // qDebug() << "updateProxies: Group" << m_key.group << "/ Item" << m_key.item;
-    m_qProxyListMutex.lock();
-    QList<ControlObjectThread*> proxyList = m_qProxyList;
-    m_qProxyListMutex.unlock();
-
-    QListIterator<ControlObjectThread*> it(proxyList);
-    while (it.hasNext())
-    {
-        obj = it.next();
-        if (obj!=pProxyNoUpdate)
-        {
-            // qDebug() << "upd" << this->getKey().item;
-            bUpdateSuccess = bUpdateSuccess && obj->setExtern(m_dValue);
-        }
-    }
-    return bUpdateSuccess;
-}
-
+*/
+
+// static
 void ControlObject::getControls(QList<ControlObject*>* pControlList) {
     m_sqCOHashMutex.lock();
     for (QHash<ConfigKey, ControlObject*>::const_iterator it = m_sqCOHash.begin();
@@ -193,6 +113,7 @@
     m_sqCOHashMutex.unlock();
 }
 
+// static
 ControlObject* ControlObject::getControl(const ConfigKey& key) {
     //qDebug() << "ControlObject::getControl for (" << key.group << "," << key.item << ")";
     QMutexLocker locker(&m_sqCOHashMutex);
@@ -205,199 +126,34 @@
     return NULL;
 }
 
-void ControlObject::queueFromThread(double dValue, ControlObjectThread * pControlObjectThread)
-{
-    QueueObjectThread * p = new QueueObjectThread;
-    p->pControlObjectThread = pControlObjectThread;
-    p->pControlObject = this;
-    p->value = dValue;
-
-    m_sqQueueMutexThread.lock();
-    m_sqQueueThread.enqueue(p);
-    m_sqQueueMutexThread.unlock();
-}
-
-void ControlObject::queueFromMidi(MidiOpCode o, double v)
-{
-    QueueObjectMidi * p = new QueueObjectMidi;
-    p->pControlObject = this;
-    p->opcode = o;
-    p->value = v;
-
-    m_sqQueueMutexMidi.lock();
-    m_sqQueueMidi.enqueue(p);
-    m_sqQueueMutexMidi.unlock();
-}
-
-void ControlObject::setValueFromEngine(double dValue)
-{
-    m_dValue = dValue;
-    if (m_bTrack) {
-        Stat::track(m_trackKey, static_cast<Stat::StatType>(m_trackType),
-                    static_cast<Stat::ComputeFlags>(m_trackFlags), m_dValue);
-    }
-    emit(valueChangedFromEngine(m_dValue));
-}
-
-void ControlObject::setValueFromMidi(MidiOpCode o, double v)
-{
-    Q_UNUSED(o);
-    m_dValue = v;
-    if (m_bTrack) {
-        Stat::track(m_trackKey, static_cast<Stat::StatType>(m_trackType),
-                    static_cast<Stat::ComputeFlags>(m_trackFlags), m_dValue);
-    }
-    emit(valueChanged(m_dValue));
-}
-
-double ControlObject::GetMidiValue()
-{
-    return m_dValue;
-}
-
-void ControlObject::setValueFromThread(double dValue)
-{
-    if (m_bIgnoreNops && m_dValue == dValue)
-        return;
-
-    m_dValue = dValue;
-    if (m_bTrack) {
-        Stat::track(m_trackKey, static_cast<Stat::StatType>(m_trackType),
-                    static_cast<Stat::ComputeFlags>(m_trackFlags), m_dValue);
-    }
-    emit(valueChanged(m_dValue));
-}
-
-void ControlObject::set(double dValue)
-{
-    if (m_bIgnoreNops && m_dValue == dValue)
-        return;
-
-    setValueFromEngine(dValue);
-    m_sqQueueMutexChanges.lock();
-    m_sqQueueChanges.enqueue(this);
-    m_sqQueueMutexChanges.unlock();
-}
-
-void ControlObject::add(double dValue)
-{
-    if (m_bIgnoreNops && !dValue)
-        return;
-
-    setValueFromEngine(m_dValue+dValue);
-    m_sqQueueMutexChanges.lock();
-    m_sqQueueChanges.enqueue(this);
-    m_sqQueueMutexChanges.unlock();
-}
-
-void ControlObject::sub(double dValue)
-{
-    if (m_bIgnoreNops && !dValue)
-        return;
-
-    setValueFromEngine(m_dValue-dValue);
-    m_sqQueueMutexChanges.lock();
-    m_sqQueueChanges.enqueue(this);
-    m_sqQueueMutexChanges.unlock();
-}
-
-double ControlObject::getValueFromWidget(double v)
-{
-    return v;
-}
-
-double ControlObject::getValueToWidget(double v)
-{
-    return v;
-}
-
-void ControlObject::sync() {
-    // Update control objects with values recieved from threads. We tryLock
-    // because ControlObject::sync() is re-entrant (even though we just run
-    // sync() in the main loop). A slot invoked by sync() can create a modal
-    // dialog which effectively blocks sync() but continues spinning the Qt
-    // event loop. When sync() runs again, it is re-entrant if the modal dialog
-    // is still up.
-    if (m_sqQueueMutexThread.tryLock()) {
-
-        // We have to make a copy of the queue otherwise we can get deadlocks
-        // since responding to a queued event via setValueFromThread can trigger
-        // a slot which in turn could cause a lock of m_sqQueueMutexThread.
-        QQueue<QueueObjectThread*> qQueueThread = m_sqQueueThread;
-        m_sqQueueThread.clear();
-        m_sqQueueMutexThread.unlock();
-
-        while (!qQueueThread.isEmpty()) {
-            QueueObjectThread* obj = qQueueThread.dequeue();
-            if (obj == NULL) {
-                continue;
-            }
-            if (obj->pControlObject) {
-                obj->pControlObject->setValueFromThread(obj->value);
-                obj->pControlObject->updateProxies(obj->pControlObjectThread);
-            }
-            delete obj;
-        }
-    }
-
-    // Update control objects with values recieved from MIDI. We tryLock because
-    // ControlObject::sync() is re-entrant (even though we just run sync() in
-    // the main loop). A slot invoked by sync() can create a modal dialog which
-    // effectively blocks sync() but continues spinning the Qt event loop. When
-    // sync() runs again, it is re-entrant if the modal dialog is still up.
-    if (m_sqQueueMutexMidi.tryLock()) {
-        // We have to make a copy of the queue otherwise we can get deadlocks
-        // since responding to a queued event via setValueFromMidi can trigger a
-        // slot which in turn could cause a lock of m_sqQueueMutexMidi.
-        QQueue<QueueObjectMidi*> qQueueMidi = m_sqQueueMidi;
-        m_sqQueueMidi.clear();
-        m_sqQueueMutexMidi.unlock();
-
-        while (!qQueueMidi.isEmpty()) {
-            QueueObjectMidi* obj = qQueueMidi.dequeue();
-            if (obj == NULL) {
-                continue;
-            }
-            if (obj->pControlObject) {
-                obj->pControlObject->setValueFromMidi(obj->opcode, obj->value);
-                obj->pControlObject->updateProxies(NULL);
-            }
-            delete obj;
-        }
-    }
-
-    // Update app threads (ControlObjectThread derived objects) with changes in
-    // the corresponding ControlObjects. These updates should only occour if no
-    // changes has been in the object from widgets, midi or application threads.
-    if (m_sqQueueMutexChanges.tryLock()) {
-        ScopedTimer t("ControlObject::sync qQueueChanges");
-        QSet<ControlObject*> setChanges = QSet<ControlObject*>::fromList(m_sqQueueChanges);
-        Stat::track("ControlObject::sync qQueueChanges dupes", Stat::UNSPECIFIED,
-                    Stat::COUNT | Stat::SUM | Stat::AVERAGE | Stat::MIN | Stat::MAX,
-                    m_sqQueueChanges.size() - setChanges.size());
-        m_sqQueueChanges.clear();
-        m_sqQueueMutexChanges.unlock();
-
-        QList<ControlObject*> failedUpdates;
-        for (QSet<ControlObject*>::iterator it = setChanges.begin();
-             it != setChanges.end(); ++it) {
-            ControlObject* obj = *it;
-            // If update is not successful, enqueue again
-            if (!obj->updateProxies()) {
-                failedUpdates.push_back(obj);
-                Stat::track("ControlObject::sync qQueueChanges failed CO update",
-                            Stat::UNSPECIFIED, Stat::COUNT | Stat::SUM | Stat::AVERAGE, 1.0);
-
-            }
-        }
-
-        // If we cannot lock the change mutex then we will just drop these
-        // updates on the floor. We can't lock() since sync() is re-entrant
-        // (potentially across multiple threads, though that should change going
-        // forward).
-        if (failedUpdates.size() > 0 && m_sqQueueMutexChanges.tryLock()) {
-            m_sqQueueChanges.append(failedUpdates);
-            m_sqQueueMutexChanges.unlock();
-        }
+void ControlObject::setValueFromMidi(MidiOpCode o, double v) {
+    if (m_pControl) {
+        m_pControl->setMidiParameter(o, v);
+    }
+}
+
+double ControlObject::getValueToMidi() const {
+    return m_pControl ? m_pControl->getMidiParameter() : 0.0;
+}
+
+void ControlObject::setValueFromThread(double dValue, QObject* pSender) {
+    if (m_pControl) {
+        m_pControl->set(dValue, pSender);
+    }
+}
+
+double ControlObject::get() const {
+    return m_pControl ? m_pControl->get() : 0.0;
+}
+
+void ControlObject::reset() {
+    if (m_pControl) {
+        m_pControl->reset(this);
+    }
+}
+
+void ControlObject::set(const double& value) {
+    if (m_pControl) {
+        m_pControl->set(value, this);
     }
 }

=== modified file 'mixxx/src/controlobject.h'
--- mixxx/src/controlobject.h	2012-12-30 18:29:15 +0000
+++ mixxx/src/controlobject.h	2013-05-17 16:35:30 +0000
@@ -23,51 +23,19 @@
 #include <QMutex>
 
 #include "configobject.h"
-#include "controlobjectthread.h"
 #include "controllers/midi/midimessage.h"
-
-class QWidget;
-class ConfigKey;
-
-struct QueueObjectThread
-{
-    ControlObjectThread *pControlObjectThread;
-    ControlObject *pControlObject;
-    double value;
-};
-
-struct QueueObjectMidi
-{
-    ControlObject *pControlObject;
-    MidiOpCode opcode;
-    double value;
-};
-
-/**
-  * ControlObjects is used as a way to share controller values between controllers, GUI and
-  * the sound engine. Whenever the value is changed by either a connected widget or a ControlEventMidi
-  * the emitValueChanged method is called which syncronizes the new value with the player thread
-  * using the semaphore protected queue.
-  *
-  * The player thread has a corresponding ControlEngine object for each ControlObject. The
-  * ControlEngine object updates the ControlObject by queueing the values, and sending them as an
-  * event to the ControlObject.
-  *
-  *@author Tue and Ken Haste Andersen
-  */
-
-class ControlObject : public QObject
-{
+#include "control/control.h"
+
+class ControlObject : public QObject {
     Q_OBJECT
-public:
+  public:
     ControlObject();
-    ControlObject(ConfigKey key, bool bIgnoreNops=true, bool track=false);
-    ControlObject(const QString& group, const QString& item, bool bIgnoreNops=true);
+    ControlObject(ConfigKey key,
+                  bool bIgnoreNops=true, bool bTrack=false);
+    ControlObject(const QString& group, const QString& item,
+                  bool bIgnoreNops=true, bool bTrack=false);
     virtual ~ControlObject();
-    /** Connect two control objects dest and src, so each time src is updated, so is dest. */
-    static bool connectControls(ConfigKey src, ConfigKey dest);
-    /** Disonnect a control object. */
-    static bool disconnectControl(ConfigKey key);
+
     /** Returns a pointer to the ControlObject matching the given ConfigKey */
     static ControlObject* getControl(const ConfigKey& key);
     static inline ControlObject* getControl(const QString& group, const QString& item) {
@@ -78,90 +46,54 @@
     // Adds all ControlObjects that currently exist to pControlList
     static void getControls(QList<ControlObject*>* pControlsList);
 
-    /** Used to add a pointer to the corresponding ControlObjectThread of this ControlObject */
-    void addProxy(ControlObjectThread *pControlObjectThread);
-    // To get rid of a proxy when the corresponding object is being deleted for example
-    void removeProxy(ControlObjectThread *pControlObjectThread);
-    /** Update proxies, execep the one given a pointer to. Returns true if all updates
-      * happend, otherwise false. */
-    bool updateProxies(ControlObjectThread *pProxyNoUpdate=0);
-    /** Return the key of the object */
-    inline ConfigKey getKey() { return m_key; }
-    /** Return the value of the ControlObject */
-    inline double get() { return m_dValue; }
-    /** Add to value. Not thread safe. */
-    void add(double dValue);
-    /** Subtract from value. Not thread safe. */
-    void sub(double dValue);
-    /** Syncronizes all ControlObjects with their corresponding proxies. */
-    static void sync();
-    /** Queue a control change from a widget. Thread safe. Blocking. */
-    void queueFromThread(double dValue, ControlObjectThread *pControlObjectThread=0);
-    /** Queue a control change from MIDI. Thread safe. Blocking. */
-    void queueFromMidi(MidiOpCode o, double v);
-    /** Return a ControlObject value, corresponding to the widget input value. Thread safe. */
-    virtual double getValueFromWidget(double dValue);
-    /** Return a widget value corresponding to the ControlObject input value. Thread safe. */
-    virtual double getValueToWidget(double dValue);
-    /** get value (range 0..127) **/
-    virtual double GetMidiValue();
-    virtual void setDefaultValue(double dValue) {
-        m_dDefaultValue = dValue;
-    }
-    virtual double defaultValue() const {
-        return m_dDefaultValue;
-    }
-
-public slots:
-    /** Sets the value of the object and updates associated proxy objects. Not thread safe. */
-    void set(double dValue);
-
-signals:
+    // Return the key of the object
+    inline ConfigKey getKey() const { return m_key; }
+    // Returns the value of the ControlObject
+    double get() const;
+    // Sets the ControlObject value
+    void set(const double& value);
+    // Sets the default value
+    void reset();
+
+    inline void setDefaultValue(double dValue) {
+        if (m_pControl) {
+            m_pControl->setDefaultValue(dValue);
+        }
+    }
+    inline double defaultValue() const {
+        return m_pControl ? m_pControl->defaultValue() : 0.0;
+    }
+
+  signals:
     void valueChanged(double);
     void valueChangedFromEngine(double);
 
-protected:
-    /** Sets the value of the object. Not thread safe. */
-    virtual void setValueFromEngine(double dValue);
-    /** Called when a widget has changed value. Not thread safe. */
+  public:
+    // DEPRECATED: Called to set the control value from the controller
+    // subsystem.
     virtual void setValueFromMidi(MidiOpCode o, double v);
-    /** Called when another thread has changed value. Not thread safe. */
-    virtual void setValueFromThread(double dValue);
+    virtual double getValueToMidi() const;
+    // DEPRECATED: Called to set the control value from another thread.
+    virtual void setValueFromThread(double dValue, QObject* pSetter);
 
-protected:
-    /** The actual value of the controller */
-    double m_dValue;
-    double m_dDefaultValue;
-    /** Key of the object */
+  protected:
+    // Key of the object
     ConfigKey m_key;
-
-private:
-    // Whether to ignore set/add/sub()'s which would have no effect
-    bool m_bIgnoreNops;
-    // Whether to track value changes with the stats framework.
-    bool m_bTrack;
-    QString m_trackKey;
-    int m_trackType;
-    int m_trackFlags;
-    /** List of associated proxy objects */
-    QList<ControlObjectThread*> m_qProxyList;
-    /** Mutex for the proxy list */
-    QMutex m_qProxyListMutex;
-
-    /** Hash of ControlObject instantiations */
+    ControlDoublePrivate* m_pControl;
+
+  private slots:
+    void privateValueChanged(double value, QObject* pSetter);
+
+  private:
+    void initialize(ConfigKey key, bool bIgnoreNops, bool bTrack);
+    inline bool ignoreNops() const {
+        return m_pControl ? m_pControl->ignoreNops() : true;
+    }
+
+    // Hash of ControlObject instantiations
     static QHash<ConfigKey,ControlObject*> m_sqCOHash;
-    /** Mutex guarding access to the ControlObject hash **/
+    // Mutex guarding access to the ControlObject hash
     static QMutex m_sqCOHashMutex;
-    /** Mutex protecting access to the queues */
-    static QMutex m_sqQueueMutexMidi, m_sqQueueMutexThread, m_sqQueueMutexChanges;
-    /** Queue holding control changes from MIDI */
-    static QQueue<QueueObjectMidi*> m_sqQueueMidi;
-    /** Queues holding control changes from other application threads and from widgets */
-    static QQueue<QueueObjectThread*> m_sqQueueThread;
-    /** Queue holding ControlObjects that has changed, but not been syncronized with it's
-     * associated ControlObjectProxy objects. */
-    static QQueue<ControlObject*> m_sqQueueChanges;
 };
 
-
 #endif

=== modified file 'mixxx/src/controlobjectthread.cpp'
--- mixxx/src/controlobjectthread.cpp	2012-12-09 22:01:39 +0000
+++ mixxx/src/controlobjectthread.cpp	2013-05-17 16:35:30 +0000
@@ -20,92 +20,63 @@
 
 #include "controlobjectthread.h"
 #include "controlobject.h"
+#include "control/control.h"
 
 ControlObjectThread::ControlObjectThread(ControlObject* pControlObject, QObject* pParent)
         : QObject(pParent),
-          m_dValue(0.0),
-          m_pControlObject(pControlObject) {
-    // Register with the associated ControlObject
-    if (m_pControlObject != NULL) {
-        m_pControlObject->addProxy(this);
-        connect(m_pControlObject, SIGNAL(destroyed()),
-                this, SLOT(slotParentDead()));
-        // Initialize value
-        m_dValue = m_pControlObject->get();
-    }
-    emitValueChanged();
+          m_key(pControlObject ? pControlObject->getKey() : ConfigKey()),
+          m_pControl(NULL) {
+    if (pControlObject) {
+        m_pControl = ControlDoublePrivate::getControl(pControlObject->getKey(), false);
+    }
+    if (m_pControl) {
+        connect(m_pControl, SIGNAL(valueChanged(double, QObject*)),
+                this, SLOT(slotValueChanged(double, QObject*)),
+                Qt::DirectConnection);
+    }
 }
 
 ControlObjectThread::~ControlObjectThread() {
-    if (m_pControlObject) {
-        // Our parent is still around, make sure it doesn't send us any more events
-        m_pControlObject->removeProxy(this);
-    }
+}
+
+bool ControlObjectThread::valid() const {
+    return m_pControl != NULL;
 }
 
 double ControlObjectThread::get() {
-    m_dataMutex.lock();
-    double v = m_dValue;
-    m_dataMutex.unlock();
-
-    return v;
+    return m_pControl ? m_pControl->get() : 0.0;
 }
 
 void ControlObjectThread::slotSet(double v) {
-    m_dataMutex.lock();
-    m_dValue = v;
-    m_dataMutex.unlock();
-
-    updateControlObject(v);
-}
-
-bool ControlObjectThread::setExtern(double v) {
-    bool result = false;
-
-    if (m_dataMutex.tryLock()) {
-        m_dValue = v;
-        result = true;
-        m_dataMutex.unlock();
-        emitValueChanged();
-    }
-
-    return result;
+    set(v);
+}
+
+void ControlObjectThread::set(double v) {
+    if (m_pControl) {
+        m_pControl->set(v, this);
+    }
+}
+
+void ControlObjectThread::reset() {
+    if (m_pControl) {
+        // NOTE(rryan): This is important. The originator of this action does
+        // not know the resulting value so it makes sense that we should emit a
+        // general valueChanged() signal even though the change originated from
+        // us. For this reason, we provide NULL here so that the change is
+        // broadcast as valueChanged() and not valueChangedByThis().
+        m_pControl->reset(NULL);
+    }
 }
 
 void ControlObjectThread::emitValueChanged() {
     emit(valueChanged(get()));
 }
 
-void ControlObjectThread::add(double v) {
-    m_dataMutex.lock();
-    double newValue = m_dValue + v;
-    m_dValue = newValue;
-    m_dataMutex.unlock();
-
-    updateControlObject(newValue);
-}
-
-void ControlObjectThread::sub(double v) {
-    m_dataMutex.lock();
-    double newValue = m_dValue - v;
-    m_dValue = newValue;
-    m_dataMutex.unlock();
-
-    updateControlObject(newValue);
-}
-
-void ControlObjectThread::updateControlObject(double v) {
-    if (m_pControlObject) {
-        m_pControlObject->queueFromThread(v, this);
+void ControlObjectThread::slotValueChanged(double v, QObject* pSetter) {
+    if (pSetter != this) {
+        // This is base implementation of this function without scaling
+        emit(valueChanged(v));
+    } else {
+        emit(valueChangedByThis(v));
     }
 }
-
-void ControlObjectThread::slotParentDead() {
-    // Now we've got a chance of avoiding segfaults with judicious
-    // use of if(m_pControlObject)
-    m_pControlObject = NULL;
-}
-
-ControlObject* ControlObjectThread::getControlObject() {
-   return m_pControlObject;
-}

=== modified file 'mixxx/src/controlobjectthread.h'
--- mixxx/src/controlobjectthread.h	2012-12-09 22:01:39 +0000
+++ mixxx/src/controlobjectthread.h	2013-05-17 16:35:30 +0000
@@ -24,6 +24,9 @@
 #include <qwaitcondition.h>
 #include <QQueue>
 
+#include "configobject.h"
+
+class ControlDoublePrivate;
 class ControlObject;
 
 class ControlObjectThread : public QObject {
@@ -32,46 +35,41 @@
     ControlObjectThread(ControlObject *pControlObject, QObject* pParent=NULL);
     virtual ~ControlObjectThread();
 
-    /** Returns the value of the object. Thread safe, blocking */
-    virtual double get();
-    /** Setting the value from an external controller. This happen when a ControlObject has
-      * changed and its value is syncronized with this object. Thread safe, non blocking. Returns
-      * true if successful, otherwise false. Thread safe, non blocking. */
-    virtual bool setExtern(double v);
-    /** Adds a value to the value property of the ControlEngine. Notification in a similar way
-     * to set. Thread safe, blocking. */
-    virtual void add(double v);
-    /** Subtracts a value to the value property. Notification in a similar way
-     * to set. Thread safe, blocking. */
-    virtual void sub(double v);
     /** Called from update(); */
     void emitValueChanged();
 
-
-    // FIXME: Dangerous GED hack
-    ControlObject* getControlObject();
-
-public slots:
-    /** The value is changed by the engine, and the corresponding ControlObject is updated.
-      * Thread safe, blocking. */
+    inline ConfigKey getKey() const {
+        return m_key;
+    }
+
+    // Returns the value of the object. Thread safe, non-blocking.
+    virtual double get();
+
+    bool valid() const;
+
+  public slots:
+    // Set the control to a new value. Non-blocking.
     virtual void slotSet(double v);
-
-    // The danger signal! This is for safety in wierd shutdown scenarios where the
-    // ControlObject dies to avoid segfaults.
-    void slotParentDead();
-
-signals:
+    // Sets the control value to v. Thread safe, non-blocking.
+    virtual void set(double v);
+    // Resets the control to its default value. Thread safe, non-blocking.
+    virtual void reset();
+
+  signals:
     void valueChanged(double);
-
-protected:
-    /** The actual value of the object */
-    double m_dValue;
-    /** Mutex controlling access to non-static members*/
-    QMutex m_dataMutex;
-    /** Pointer to corresponding ControlObject */
-    ControlObject *m_pControlObject;
-    /** Update corresponding ControlObject to the value */
-    virtual void updateControlObject(double v);
+    // This means that the control value has changed as a result of a mutation
+    // (set/add/sub/reset) originating from this object.
+    void valueChangedByThis(double);
+
+  protected slots:
+    // Receives the value from the master control and re-emits either
+    // valueChanged(double) or valueChangedByThis(double) based on pSetter.
+    virtual void slotValueChanged(double v, QObject* pSetter);
+
+  protected:
+    ConfigKey m_key;
+    // Pointer to connected control.
+    ControlDoublePrivate* m_pControl;
 };
 
 #endif

=== modified file 'mixxx/src/controlobjectthreadmain.cpp'
--- mixxx/src/controlobjectthreadmain.cpp	2012-12-10 07:13:01 +0000
+++ mixxx/src/controlobjectthreadmain.cpp	2013-05-17 16:35:30 +0000
@@ -16,34 +16,34 @@
     installEventFilter(this);
 }
 
-ControlObjectThreadMain::~ControlObjectThreadMain() {
-}
-
-bool ControlObjectThreadMain::eventFilter(QObject * o, QEvent * e)
-{
+bool ControlObjectThreadMain::eventFilter(QObject* o, QEvent* e) {
     // Handle events
     if (e && e->type() == MIXXXEVENT_CONTROL) {
         ControlEvent * ce = (ControlEvent *)e;
-        //qDebug() << "ControlEvent " << ce->value();
-        m_dValue = ce->value();
         emit(valueChanged(ce->value()));
     } else {
-        // standard event processing
         return QObject::eventFilter(o,e);
     }
     return true;
 }
 
-bool ControlObjectThreadMain::setExtern(double v)
-{
+void ControlObjectThreadMain::slotValueChanged(double, QObject* pSetter) {
+    // The value argument to this function is in value space, but for some of
+    // our subclasses (e.g. ControlObjectThreadWidget) emit valueChanged(double)
+    // should emit in parameter space. So we emit the value of get() instead
+    // which will get the correct value.
+
     // If we are already running in the main thread, then go ahead and update.
     if (QThread::currentThread() == QApplication::instance()->thread()) {
-        m_dValue = v;
-        emit(valueChanged(v));
+        if (pSetter != this) {
+            emit(valueChanged(get()));
+        } else {
+            emit(valueChangedByThis(get()));
+        }
     } else {
         // Otherwise, we have to post the event to the main thread event queue
         // and then catch the event via eventFilter.
-        QApplication::postEvent(this, new ControlEvent(v));
+        QApplication::postEvent(this, new ControlEvent(get()));
     }
-    return true;
+
 }

=== modified file 'mixxx/src/controlobjectthreadmain.h'
--- mixxx/src/controlobjectthreadmain.h	2012-12-09 22:01:39 +0000
+++ mixxx/src/controlobjectthreadmain.h	2013-05-17 16:35:30 +0000
@@ -12,7 +12,7 @@
 // ControlObjectThreadMain is a variant of ControlObjectThread that should only
 // ever have its methods called by the main thread. The benefit is that the
 // valueChanged() signal is proxied to the main thread automatically and the
-// get()/set()/add()/sub() methods are lock-free and performant relative to
+// get()/set() methods are lock-free and performant relative to
 // ControlObjectThread since COT requires using a mutex to maintain the
 // integrity of the control value. If you create a COTM, you must make sure to
 // only call its methods from the main thread.
@@ -20,29 +20,14 @@
     Q_OBJECT
   public:
     ControlObjectThreadMain(ControlObject *pControlObject, QObject* pParent=NULL);
-    virtual ~ControlObjectThreadMain();
-    /** Event filter */
-    bool eventFilter(QObject *o, QEvent *e);
-    /** Notify this object through events */
-    virtual bool setExtern(double v);
-
-    // No lock is needed for get()/add()/sub()/slotSet(). See class comment above.
-    virtual inline double get() { return m_dValue; }
-    virtual inline void add(double v) {
-        // Would not be safe if m_dValue were not safe for use in the main
-        // thread!
-        slotSet(m_dValue + v);
-    }
-    virtual inline void sub(double v) {
-        // Would not be safe if m_dValue were not safe for use in the main
-        // thread!
-        slotSet(m_dValue - v);
-    }
-  public slots:
-    virtual inline void slotSet(double v) {
-        m_dValue = v;
-        updateControlObject(v);
-    }
+
+    bool eventFilter(QObject* o, QEvent* e);
+
+  protected slots:
+    // Receives the value from the master control, proxies it to the main
+    // thread, and re-emits either valueChanged(double) or
+    // valueChangedByThis(double) based on pSetter.
+    virtual void slotValueChanged(double v, QObject* pSetter);
 };
 
 #endif

=== modified file 'mixxx/src/controlobjectthreadwidget.cpp'
--- mixxx/src/controlobjectthreadwidget.cpp	2012-12-09 22:01:39 +0000
+++ mixxx/src/controlobjectthreadwidget.cpp	2013-05-17 16:35:30 +0000
@@ -6,13 +6,6 @@
 
 ControlObjectThreadWidget::ControlObjectThreadWidget(ControlObject * pControlObject, QObject* pParent)
         : ControlObjectThreadMain(pControlObject, pParent) {
-    // ControlObjectThread's constructor sets m_dValue to
-    // m_pControlObject->get(). Since we represent the widget's value, we need
-    // to reset m_dValue to be the result of getValueToWidget.
-    if (m_pControlObject != NULL) {
-        m_dValue = m_pControlObject->getValueToWidget(m_pControlObject->get());
-        emitValueChanged();
-    }
 }
 
 ControlObjectThreadWidget::~ControlObjectThreadWidget() {
@@ -23,30 +16,44 @@
                                           EmitOption emitOption, Qt::MouseButton state) {
     if (connectValueFromWidget) {
         connect(widget, SIGNAL(valueReset()),
-                this, SLOT(slotReset()));
+                this, SLOT(reset()));
 
         if (emitOption & EMIT_ON_PRESS) {
-            if (state == Qt::NoButton)
+            switch (state) {
+            case Qt::NoButton:
                 connect(widget, SIGNAL(valueChangedDown(double)),
                         this, SLOT(slotSet(double)));
-            else if (state == Qt::LeftButton)
+                break;
+            case Qt::LeftButton:
                 connect(widget, SIGNAL(valueChangedLeftDown(double)),
                         this, SLOT(slotSet(double)));
-            else if (state == Qt::RightButton)
+                break;
+            case Qt::RightButton:
                 connect(widget, SIGNAL(valueChangedRightDown(double)),
                         this, SLOT(slotSet(double)));
+                break;
+            default:
+                break;
+            }
         }
 
         if (emitOption & EMIT_ON_RELEASE) {
-            if (state == Qt::NoButton)
+            switch (state) {
+            case Qt::NoButton:
                 connect(widget, SIGNAL(valueChangedUp(double)),
                         this, SLOT(slotSet(double)));
-            else if (state == Qt::LeftButton)
+                break;
+            case Qt::LeftButton:
                 connect(widget, SIGNAL(valueChangedLeftUp(double)),
                         this, SLOT(slotSet(double)));
-            else if (state == Qt::RightButton)
+                break;
+            case Qt::RightButton:
                 connect(widget, SIGNAL(valueChangedRightUp(double)),
                         this, SLOT(slotSet(double)));
+                break;
+            default:
+                break;
+            }
         }
     }
 
@@ -54,42 +61,22 @@
         connect(this, SIGNAL(valueChanged(double)),
                 widget, SLOT(setValue(double)));
     }
-    emitValueChanged();
+    emit(valueChanged(get()));
 }
 
 void ControlObjectThreadWidget::setWidgetOnOff(QWidget* widget)
 {
     QApplication::connect(this, SIGNAL(valueChanged(double)),
                           widget, SLOT(setOnOff(double)));
-    emit(valueChanged(m_dValue));
-}
-
-void ControlObjectThreadWidget::slotReset() {
-    if (m_pControlObject != NULL) {
-        double defaultValue = m_pControlObject->defaultValue();
-        // defaultValue is a control value. slotSet needs to be set with a widget
-        // value since widget value-changed signals connect to it. setExtern needs
-        // to be called with a control value since it is triggered by control
-        // updates.
-        slotSet(m_pControlObject->getValueToWidget(defaultValue));
-        setExtern(defaultValue);
-    }
-}
-
-void ControlObjectThreadWidget::updateControlObject(double v)
-{
-    if (m_pControlObject != NULL) {
-        m_pControlObject->queueFromThread(
-            m_pControlObject->getValueFromWidget(v), this);
-    }
-}
-
-bool ControlObjectThreadWidget::setExtern(double v) {
-    //qDebug() << "set extern widget";
-    if (m_pControlObject != NULL) {
-        // COTM just emits v here. Instead we need to transform the value with
-        // getValueToWidget.
-        QApplication::postEvent(this, new ControlEvent(m_pControlObject->getValueToWidget(v)));
-    }
-    return true;
+    emit(valueChanged(get()));
+}
+
+double ControlObjectThreadWidget::get() {
+    return m_pControl ? m_pControl->getWidgetParameter() : 0.0;
+}
+
+void ControlObjectThreadWidget::set(double v) {
+    if (m_pControl) {
+        m_pControl->setWidgetParameter(v, this);
+    }
 }

=== modified file 'mixxx/src/controlobjectthreadwidget.h'
--- mixxx/src/controlobjectthreadwidget.h	2012-12-09 22:01:39 +0000
+++ mixxx/src/controlobjectthreadwidget.h	2013-05-17 16:35:30 +0000
@@ -22,10 +22,9 @@
 @author Tue Haste Andersen
 */
 
-class ControlObjectThreadWidget : public ControlObjectThreadMain
-{
+class ControlObjectThreadWidget : public ControlObjectThreadMain {
     Q_OBJECT
-public:
+  public:
 
     enum EmitOption {
         EMIT_NEVER                = 0x00,
@@ -42,13 +41,11 @@
                    EmitOption emitOption=EMIT_ON_PRESS, Qt::MouseButton state=Qt::NoButton);
     /** Associates a the enabled/disabled state of a widget with the state of a ControlObject. */
     void setWidgetOnOff(QWidget *widget);
-    bool setExtern(double v);
-
-  private slots:
-    void slotReset();
-
-  private:
-    virtual void updateControlObject(double v);
+
+    virtual double get();
+
+  public slots:
+    virtual void set(double v);
 };
 
 #endif

=== modified file 'mixxx/src/controlpotmeter.cpp'
--- mixxx/src/controlpotmeter.cpp	2012-04-27 07:47:21 +0000
+++ mixxx/src/controlpotmeter.cpp	2013-05-17 16:35:30 +0000
@@ -27,11 +27,11 @@
                      potmeter is changed.
             midicontroller - pointer to the midi controller.
    -------- ------------------------------------------------------ */
-ControlPotmeter::ControlPotmeter(ConfigKey key, double dMinValue, double dMaxValue) : ControlObject(key)
-{
-    setRange(dMinValue,dMaxValue);
-    setStep(m_dValueRange/10.f);
-    setSmallStep(m_dValueRange/100.f);
+ControlPotmeter::ControlPotmeter(ConfigKey key, double dMinValue, double dMaxValue)
+    : ControlObject(key) {
+    setRange(dMinValue, dMaxValue);
+    setStep(m_dValueRange / 10.f);
+    setSmallStep(m_dValueRange / 100.f);
 
     // These controls are deleted when this ControlPotmeter is since we set
     // their parent as this.
@@ -100,13 +100,11 @@
 {
 }
 
-double ControlPotmeter::getMin()
-{
+double ControlPotmeter::getMin() const {
     return m_dMinValue;
 }
 
-double ControlPotmeter::getMax()
-{
+double ControlPotmeter::getMax() const {
     return m_dMaxValue;
 }
 
@@ -124,73 +122,30 @@
 {
     m_dMinValue = dMinValue;
     m_dMaxValue = dMaxValue;
-    m_dValueRange = m_dMaxValue-m_dMinValue;
-    m_dValue = m_dMinValue + 0.5*m_dValueRange;
-    m_dDefaultValue = m_dValue;
+    m_dValueRange = m_dMaxValue - m_dMinValue;
+    double default_value = m_dMinValue + 0.5 * m_dValueRange;
+
+    if (m_pControl) {
+        ControlNumericBehavior* pOldBehavior = m_pControl->setBehavior(
+            new ControlPotmeterBehavior(dMinValue, dMaxValue));
+        delete pOldBehavior;
+    }
+
+    setDefaultValue(default_value);
+    set(default_value);
     //qDebug() << "" << this << ", min " << m_dMinValue << ", max " << m_dMaxValue << ", range " << m_dValueRange << ", val " << m_dValue;
 }
 
-double ControlPotmeter::getValueToWidget(double dValue)
-{
-    double out = (dValue-m_dMinValue)/m_dValueRange;
-    return (out < 0.5) ? out*128. : out*126. + 1.;
-}
-
-double ControlPotmeter::GetMidiValue()
-{
-    double out = (m_dValue-m_dMinValue)/m_dValueRange;
-    return (out < 0.5) ? out*128. : out*126. + 1.;
-}
-
-double ControlPotmeter::getValueFromWidget(double dValue)
-{
-    double out = (dValue < 64) ? dValue / 128. : (dValue-1) / 126.;
-    return m_dMinValue + out * m_dValueRange;
-}
-
-void ControlPotmeter::setValueFromThread(double dValue)
-{
-    if (dValue == m_dValue) return;
-
-    if (dValue>m_dMaxValue)
-        m_dValue = m_dMaxValue;
-    else if (dValue<m_dMinValue)
-        m_dValue = m_dMinValue;
-    else
-        m_dValue = dValue;
-    emit(valueChanged(m_dValue));
-}
-
-void ControlPotmeter::setValueFromEngine(double dValue)
-{
-    if (dValue>m_dMaxValue)
-        m_dValue = m_dMaxValue;
-    else if (dValue<m_dMinValue)
-        m_dValue = m_dMinValue;
-    else
-        m_dValue = dValue;
-    emit(valueChangedFromEngine(m_dValue));
-}
-
-void ControlPotmeter::setValueFromMidi(MidiOpCode o, double v)
-{
-    Q_UNUSED(o);
-    double out = (v < 64) ? v / 128. : (v-1) / 126.;
-    m_dValue = m_dMinValue + out*m_dValueRange;
-    emit(valueChanged(m_dValue));
-}
-
 void ControlPotmeter::incValue(double keypos)
 {
     if (keypos>0)
     {
-        m_dValue += m_dStep;
-        if (m_dValue > m_dMaxValue)
-            m_dValue = m_dMaxValue;
-        emit(valueChanged(m_dValue));
-
-        // incValue will be activated by assosiated _up or _down ControlObject, and thus it is safe to update all proxies.
-        updateProxies(0);
+        double value = get();
+        value += m_dStep;
+        if (value > m_dMaxValue) {
+            value = m_dMaxValue;
+        }
+        set(value);
     }
 }
 
@@ -198,13 +153,13 @@
 {
     if (keypos>0)
     {
-        m_dValue -= m_dStep;
-        if (m_dValue < m_dMinValue)
-            m_dValue = m_dMinValue;
-        emit(valueChanged(m_dValue));
+        double value = get();
 
-        // decValue will be activated by assosiated _up or _down ControlObject, and thus it is safe to update all proxies.
-        updateProxies(0);
+        value -= m_dStep;
+        if (value < m_dMinValue) {
+            value = m_dMinValue;
+        }
+        set(value);
     }
 }
 
@@ -212,13 +167,12 @@
 {
     if (keypos>0)
     {
-        m_dValue += m_dSmallStep;
-        if (m_dValue > m_dMaxValue)
-            m_dValue = m_dMaxValue;
-        emit(valueChanged(m_dValue));
-
-        // incSmallValue will be activated by assosiated _up_small or _down_small ControlObject, and thus it is safe to update all proxies.
-        updateProxies(0);
+        double value = get();
+        value += m_dSmallStep;
+        if (value > m_dMaxValue) {
+            value = m_dMaxValue;
+        }
+        set(value);
     }
 }
 
@@ -226,13 +180,12 @@
 {
     if (keypos>0)
     {
-        m_dValue -= m_dSmallStep;
-        if (m_dValue < m_dMinValue)
-            m_dValue = m_dMinValue;
-        emit(valueChanged(m_dValue));
-
-        // decSmallValue will be activated by assosiated _up_small or _down_small ControlObject, and thus it is safe to update all proxies.
-        updateProxies(0);
+        double value = get();
+        value -= m_dSmallStep;
+        if (value < m_dMinValue) {
+            value = m_dMinValue;
+        }
+        set(value);
     }
 }
 
@@ -240,9 +193,7 @@
 {
     if (keypos>0)
     {
-        m_dValue = 0.0;
-        emit(valueChanged(m_dValue));
-        updateProxies(0);
+        set(0.0);
     }
 }
 
@@ -250,9 +201,7 @@
 {
     if (keypos>0)
     {
-        m_dValue = 1.0;
-        emit(valueChanged(m_dValue));
-        updateProxies(0);
+        set(1.0);
     }
 }
 
@@ -260,51 +209,35 @@
 {
     if (keypos>0)
     {
-        m_dValue = -1.0;
-        emit(valueChanged(m_dValue));
-        updateProxies(0);
+        set(-1.0);
     }
 }
 
 void ControlPotmeter::setToDefault(double v) {
     if (v > 0) {
-        m_dValue = m_dDefaultValue;
-        emit(valueChanged(m_dValue));
-        updateProxies(0);
-    }
-}
-
-void ControlPotmeter::toggleValue(double keypos)
-{
-    if (keypos>0)
-    {
-        if (m_dValue > 0.0)
-        {
-            m_dValue = 0.0;
-        }
-        else
-        {
-            m_dValue = 1.0;
-        }
-        emit(valueChanged(m_dValue));
-        updateProxies(0);
-    }
-}
-
-void ControlPotmeter::toggleMinusValue(double keypos)
-{
-    if (keypos>0)
-    {
-        if (m_dValue > 0.0)
-        {
-            m_dValue = -1.0;
-        }
-        else
-        {
-            m_dValue = 1.0;
-        }
-        emit(valueChanged(m_dValue));
-        updateProxies(0);
+        reset();
+    }
+}
+
+void ControlPotmeter::toggleValue(double keypos) {
+    if (keypos>0) {
+        double value = get();
+        if (value > 0.0) {
+            set(0.0);
+        } else {
+            set(1.0);
+        }
+    }
+}
+
+void ControlPotmeter::toggleMinusValue(double keypos) {
+    if (keypos>0) {
+        double value = get();
+        if (value > 0.0) {
+            set(-1.0);
+        } else {
+            set(1.0);
+        }
     }
 }
 

=== modified file 'mixxx/src/controlpotmeter.h'
--- mixxx/src/controlpotmeter.h	2012-04-27 07:47:21 +0000
+++ mixxx/src/controlpotmeter.h	2013-05-17 16:35:30 +0000
@@ -35,23 +35,15 @@
     ControlPotmeter(ConfigKey key, double dMinValue=0.0, double dMaxValue=1.0);
     ~ControlPotmeter();
     /** Returns the minimum allowed value */
-    double getMin();
+    double getMin() const;
     /** Returns the maximum allowed value */
-    double getMax();
+    double getMax() const;
     /** Sets the step size of the associated PushButtons */
     void setStep(double);
     /** Sets the small step size of the associated PushButtons */
     void setSmallStep(double);
-    /** Sets the minimum and maximum allowed value. The control value is reset when calling
-      * this method */
-    void setRange(double dMinValue, double dMaxValue);
-    double getValueFromWidget(double dValue);
-    double getValueToWidget(double dValue);
-    double GetMidiValue();
 
 public slots:
-    void setValueFromThread(double dValue);
-    void setValueFromEngine(double dValue);
     /** Increases the value. This method is called from an associated PushButton control */
     void incValue(double);
     /** Decreases the value. This method is called from an associated PushButton control */
@@ -74,9 +66,15 @@
     void toggleMinusValue(double);
 
 protected:
-    void setValueFromMidi(MidiOpCode o, double v);
+    /** Sets the minimum and maximum allowed value. The control value is reset when calling
+      * this method */
+    void setRange(double dMinValue, double dMaxValue);
 
-    double m_dMaxValue, m_dMinValue, m_dValueRange, m_dStep, m_dSmallStep;
+    double m_dMaxValue;
+    double m_dMinValue;
+    double m_dValueRange;
+    double m_dStep;
+    double m_dSmallStep;
 };
 
 #endif

=== modified file 'mixxx/src/controlpushbutton.cpp'
--- mixxx/src/controlpushbutton.cpp	2012-07-09 21:38:03 +0000
+++ mixxx/src/controlpushbutton.cpp	2013-05-17 16:35:30 +0000
@@ -17,9 +17,6 @@
 
 #include "controlpushbutton.h"
 
-// static
-const int ControlPushButton::kPowerWindowTimeMillis = 300;
-
 /* -------- ------------------------------------------------------
    Purpose: Creates a new simulated latching push-button.
    Input:   key - Key for the configuration file
@@ -28,6 +25,13 @@
         ControlObject(key, false),
         m_buttonMode(PUSH),
         m_iNoStates(2) {
+    if (m_pControl) {
+        ControlNumericBehavior* pOldBehavior = m_pControl->setBehavior(
+            new ControlPushButtonBehavior(
+                static_cast<ControlPushButtonBehavior::ButtonMode>(m_buttonMode),
+                m_iNoStates));
+        delete pOldBehavior;
+    }
 }
 
 ControlPushButton::~ControlPushButton() {
@@ -37,57 +41,25 @@
 void ControlPushButton::setButtonMode(enum ButtonMode mode) {
     //qDebug() << "Setting " << m_Key.group << m_Key.item << "as toggle";
     m_buttonMode = mode;
+
+    if (m_pControl) {
+        ControlNumericBehavior* pOldBehavior = m_pControl->setBehavior(
+            new ControlPushButtonBehavior(
+                static_cast<ControlPushButtonBehavior::ButtonMode>(m_buttonMode),
+                m_iNoStates));
+        delete pOldBehavior;
+    }
 }
 
 void ControlPushButton::setStates(int num_states) {
     m_iNoStates = num_states;
-}
-
-void ControlPushButton::setValueFromMidi(MidiOpCode o, double v) {
-    // keyboard events are handled by this function as well
-    //if (m_bMidiSimulateLatching)
-
-    //qDebug() << "bMidiSimulateLatching is true!";
-    // Only react on NOTE_ON midi events if simulating latching...
-
-    //qDebug() << o << v;
-
-    // This block makes push-buttons act as power window buttons.
-    if (m_buttonMode == POWERWINDOW && m_iNoStates == 2) {
-        if (o == MIDI_NOTE_ON) {
-            if (v > 0.) {
-                m_dValue = !m_dValue;
-                m_pushTimer.setSingleShot(true);
-                m_pushTimer.start(kPowerWindowTimeMillis);
-            }
-        } else if (o == MIDI_NOTE_OFF) {
-            if (!m_pushTimer.isActive()) {
-                m_dValue = 0.0;
-            }
-        }
-    } else if (m_buttonMode == TOGGLE) {
-        // This block makes push-buttons act as toggle buttons.
-        if (m_iNoStates > 2) { //multistate button
-            if (v > 0.) { //looking for NOTE_ON doesn't seem to work...
-                m_dValue++;
-                if (m_dValue >= m_iNoStates)
-                    m_dValue = 0;
-            }
-        } else {
-            if (o == MIDI_NOTE_ON) {
-                if (v > 0.) {
-                    m_dValue = !m_dValue;
-                }
-            }
-        }
-    } else { //Not a toggle button (trigger only when button pushed)
-        if (o == MIDI_NOTE_ON) {
-            m_dValue = !m_dValue;
-        } else if (o == MIDI_NOTE_OFF) {
-            m_dValue = 0.0;
-        }
+
+    if (m_pControl) {
+        ControlNumericBehavior* pOldBehavior = m_pControl->setBehavior(
+            new ControlPushButtonBehavior(
+                static_cast<ControlPushButtonBehavior::ButtonMode>(m_buttonMode),
+                m_iNoStates));
+        delete pOldBehavior;
     }
-
-    emit(valueChanged(m_dValue));
 }
 

=== modified file 'mixxx/src/controlpushbutton.h'
--- mixxx/src/controlpushbutton.h	2012-05-01 05:59:37 +0000
+++ mixxx/src/controlpushbutton.h	2013-05-17 16:35:30 +0000
@@ -21,7 +21,6 @@
 #include "controlobject.h"
 #include "controllers/midi/midimessage.h"
 #include "defs.h"
-#include <QTimer>
 
 /**
   *@author Tue and Ken Haste Andersen
@@ -31,11 +30,10 @@
     Q_OBJECT
   public:
     enum ButtonMode {
-         PUSH,
+         PUSH = 0,
          TOGGLE,
          POWERWINDOW
     };
-    static const int kPowerWindowTimeMillis;
 
     ControlPushButton(ConfigKey key);
     virtual ~ControlPushButton();
@@ -46,13 +44,9 @@
     void setButtonMode(enum ButtonMode mode);
     void setStates(int num_states);
 
-  protected:
-    void setValueFromMidi(MidiOpCode o, double v);
-
   private:
     enum ButtonMode m_buttonMode;
     int m_iNoStates;
-    QTimer m_pushTimer;
 };
 
 #endif

=== modified file 'mixxx/src/controlttrotary.cpp'
--- mixxx/src/controlttrotary.cpp	2012-03-17 17:42:44 +0000
+++ mixxx/src/controlttrotary.cpp	2013-05-17 16:35:30 +0000
@@ -20,31 +20,13 @@
    Purpose: Creates a new rotary encoder
    Input:   key
    -------- ------------------------------------------------------ */
-ControlTTRotary::ControlTTRotary(ConfigKey key) : ControlObject(key)
-{
-}
-
-double ControlTTRotary::getValueFromWidget(double dValue)
-{
-    // Non-linear scaling
-    double temp = (((dValue-64.)*(dValue-64.))/64.);
-    if ((dValue-64.)<0)
-        temp = -temp;
-
-    //qDebug() << "tt rotary in " << dValue << ", out " << temp;
-
-    return temp; //dValue-64.;
-}
-
-double ControlTTRotary::getValueToWidget(double dValue)
-{
-    return dValue*200.+64.;
-}
-
-void ControlTTRotary::setValueFromMidi(MidiOpCode o, double v)
-{
-    Q_UNUSED(o);
-    m_dValue = v;
-    emit(valueChanged(m_dValue));
-}
+ControlTTRotary::ControlTTRotary(ConfigKey key) : ControlObject(key) {
+    if (m_pControl) {
+        ControlNumericBehavior* pOldBehavior = m_pControl->setBehavior(
+            new ControlTTRotaryBehavior());
+        delete pOldBehavior;
+    }
+}
+
+
 

=== modified file 'mixxx/src/controlttrotary.h'
--- mixxx/src/controlttrotary.h	2012-03-17 17:42:44 +0000
+++ mixxx/src/controlttrotary.h	2013-05-17 16:35:30 +0000
@@ -20,20 +20,10 @@
 #include "configobject.h"
 #include "controlobject.h"
 
-/** Turn Table rotary controller class. The turntable rotary sends midi events: 0 when turning
-  * backwards, and 1 when turning forward. This class keeps track of it's speed, using a timer
-  * interrupt */
-class ControlTTRotary : public ControlObject
-{
+class ControlTTRotary : public ControlObject {
     Q_OBJECT
-public:
+  public:
     ControlTTRotary(ConfigKey key);
-    
-    double getValueFromWidget(double dValue);
-    double getValueToWidget(double dValue);
-    
-protected:
-    void setValueFromMidi(MidiOpCode o, double v);
 };
 
 #endif

=== modified file 'mixxx/src/dlgprefeq.cpp'
--- mixxx/src/dlgprefeq.cpp	2012-04-29 15:54:21 +0000
+++ mixxx/src/dlgprefeq.cpp	2013-05-17 16:35:30 +0000
@@ -15,8 +15,6 @@
 *                                                                         *
 ***************************************************************************/
 
-#include "dlgprefeq.h"
-#include "engine/enginefilteriir.h"
 #include <qlineedit.h>
 #include <qwidget.h>
 #include <qslider.h>
@@ -28,6 +26,10 @@
 
 #include <assert.h>
 
+#include "dlgprefeq.h"
+#include "engine/enginefilteriir.h"
+#include "controlobject.h"
+
 #define CONFIG_KEY "[Mixer Profile]"
 
 const int kFrequencyUpperLimit = 20050;

=== modified file 'mixxx/src/dlgprefeq.h'
--- mixxx/src/dlgprefeq.h	2011-12-06 19:40:07 +0000
+++ mixxx/src/dlgprefeq.h	2013-05-17 16:35:30 +0000
@@ -21,7 +21,7 @@
 #include "ui_dlgprefeqdlg.h"
 #include "configobject.h"
 #include "engine/enginefilterblock.h"
-#include "controlobject.h"
+#include "controlobjectthread.h"
 
 class QWidget;
 /**

=== modified file 'mixxx/src/dlgtrackinfo.h'
--- mixxx/src/dlgtrackinfo.h	2010-09-10 06:04:12 +0000
+++ mixxx/src/dlgtrackinfo.h	2013-05-17 16:35:30 +0000
@@ -10,7 +10,15 @@
 #include "ui_dlgtrackinfo.h"
 
 #include "trackinfoobject.h"
-#include "controlbeat.h"
+
+/** Minimum allowed Beat per minute (BPM) */
+const int minBPM = 30;
+/** Maximum allowed bpm */
+const int maxBPM = 240;
+/** Maximum allowed interval between beats in milli seconds (calculated from minBPM) */
+const int maxInterval = (int)(1000.*(60./(CSAMPLE)minBPM));
+/** Filter length */
+const int filterLength = 5;
 
 class Cue;
 

=== modified file 'mixxx/src/engine/bpmcontrol.cpp'
--- mixxx/src/engine/bpmcontrol.cpp	2013-03-31 16:56:35 +0000
+++ mixxx/src/engine/bpmcontrol.cpp	2013-05-17 16:35:30 +0000
@@ -145,7 +145,7 @@
     double averageBpm = 60.0 * 1000.0 / averageLength;
     double dRate = 1.0 + m_pRateDir->get() * m_pRateRange->get() * m_pRateSlider->get();
     m_pFileBpm->set(averageBpm / dRate);
-    slotAdjustBpm(); 
+    slotAdjustBpm();
 }
 
 void BpmControl::slotControlBeatSyncPhase(double v) {

=== modified file 'mixxx/src/engine/enginemaster.cpp'
--- mixxx/src/engine/enginemaster.cpp	2013-05-11 18:05:26 +0000
+++ mixxx/src/engine/enginemaster.cpp	2013-05-17 16:35:30 +0000
@@ -32,7 +32,6 @@
 #include "enginevumeter.h"
 #include "enginexfader.h"
 #include "engine/sidechain/enginesidechain.h"
-#include "engine/syncworker.h"
 #include "sampleutil.h"
 #include "util/timer.h"
 
@@ -45,7 +44,6 @@
                            bool bEnableSidechain) {
     m_pWorkerScheduler = new EngineWorkerScheduler(this);
     m_pWorkerScheduler->start();
-    m_pSyncWorker = new SyncWorker(m_pWorkerScheduler);
 
     // Master sample rate
     m_pMasterSampleRate = new ControlObject(ConfigKey(group, "samplerate"), true, true);
@@ -148,7 +146,6 @@
     }
 
     delete m_pWorkerScheduler;
-    delete m_pSyncWorker;
 }
 
 const CSAMPLE* EngineMaster::getMasterBuffer() const
@@ -440,9 +437,6 @@
     //Master/headphones interleaving is now done in
     //SoundManager::requestBuffer() - Albert Nov 18/07
 
-    // Schedule a ControlObject sync
-    m_pSyncWorker->schedule();
-
     // We're close to the end of the callback. Wake up the engine worker
     // scheduler so that it runs the workers.
     m_pWorkerScheduler->runWorkers();

=== modified file 'mixxx/src/engine/enginemaster.h'
--- mixxx/src/engine/enginemaster.h	2013-05-07 18:28:07 +0000
+++ mixxx/src/engine/enginemaster.h	2013-05-17 16:35:30 +0000
@@ -135,7 +135,6 @@
     CSAMPLE *m_pMaster, *m_pHead;
 
     EngineWorkerScheduler *m_pWorkerScheduler;
-    SyncWorker* m_pSyncWorker;
 
     ControlObject* m_pMasterVolume;
     ControlObject* m_pHeadVolume;

=== modified file 'mixxx/src/engine/loopingcontrol.cpp'
--- mixxx/src/engine/loopingcontrol.cpp	2013-05-14 22:49:05 +0000
+++ mixxx/src/engine/loopingcontrol.cpp	2013-05-17 16:35:30 +0000
@@ -408,7 +408,7 @@
         // If we're looping, stop looping
         if (m_bLoopingEnabled) {
             setLoopingEnabled(false);
-        } 
+        }
     }
 }
 
@@ -442,6 +442,12 @@
         newpos--;
     }
 
+
+    if (m_iLoopStartSample == newpos) {
+        //nothing to do
+        return;
+    }
+
     clearActiveBeatLoop();
 
     if (pos == -1.0f) {
@@ -469,6 +475,11 @@
         newpos--;
     }
 
+    if (m_iLoopEndSample == newpos) {
+        //nothing to do
+        return;
+    }
+
     // Reject if the loop-in is not set, or if the new position is before the
     // start point (but not -1).
     if (m_iLoopStartSample == -1 ||
@@ -583,6 +594,19 @@
 void LoopingControl::slotBeatLoop(double beats, bool keepStartPoint) {
     int samples = m_pTrackSamples->get();
     if (!m_pTrack || samples == 0) {
+        clearActiveBeatLoop();
+        return;
+    }
+
+
+    if (!m_pBeats) {
+        clearActiveBeatLoop();
+        return;
+    }
+
+    // For now we do not handle negative beatloops.
+    if (beats < 0) {
+        clearActiveBeatLoop();
         return;
     }
 
@@ -590,12 +614,14 @@
     // fine.
     foreach (BeatLoopingControl* pBeatLoopControl, m_beatLoops) {
         if (pBeatLoopControl->getSize() == beats) {
-            if (m_pActiveBeatLoop &&
-                m_pActiveBeatLoop != pBeatLoopControl) {
-                m_pActiveBeatLoop->deactivate();
+            if (m_pActiveBeatLoop != pBeatLoopControl) {
+                if (m_pActiveBeatLoop) {
+                    m_pActiveBeatLoop->deactivate();
+                }
+                m_pActiveBeatLoop = pBeatLoopControl;
             }
-            m_pActiveBeatLoop = pBeatLoopControl;
             pBeatLoopControl->activate();
+            break;
         }
     }
 
@@ -603,17 +629,6 @@
     int loop_in = -1;
     int loop_out = -1;
 
-    if (!m_pBeats) {
-        clearActiveBeatLoop();
-        return;
-    }
-
-    // For now we do not handle negative beatloops.
-    if (beats < 0) {
-        clearActiveBeatLoop();
-        return;
-    }
-
     // For positive numbers we start from the current position/closest beat and
     // create the loop around X beats from there.
     if (beats > 0) {
@@ -729,15 +744,19 @@
 }
 
 void BeatLoopingControl::deactivate() {
-    m_bActive = false;
-    m_pEnabled->set(0);
-    m_pLegacy->set(0);
+    if (m_bActive) {
+        m_bActive = false;
+        m_pEnabled->set(0);
+        m_pLegacy->set(0);
+    }
 }
 
 void BeatLoopingControl::activate() {
-    m_bActive = true;
-    m_pEnabled->set(1);
-    m_pLegacy->set(1);
+    if (!m_bActive) {
+        m_bActive = true;
+        m_pEnabled->set(1);
+        m_pLegacy->set(1);
+    }
 }
 
 void BeatLoopingControl::slotLegacy(double v) {

=== modified file 'mixxx/src/engine/ratecontrol.cpp'
--- mixxx/src/engine/ratecontrol.cpp	2013-05-01 13:38:41 +0000
+++ mixxx/src/engine/ratecontrol.cpp	2013-05-17 16:35:30 +0000
@@ -258,28 +258,33 @@
 {
     // Adjusts temp rate down if button pressed
     if (buttonRatePermDown->get())
-        m_pRateSlider->sub(m_pRateDir->get() * m_dPerm / (100. * m_pRateRange->get()));
+        m_pRateSlider->set(m_pRateSlider->get() -
+                           m_pRateDir->get() * m_dPerm / (100. * m_pRateRange->get()));
 }
 
 void RateControl::slotControlRatePermDownSmall(double)
 {
     // Adjusts temp rate down if button pressed
     if (buttonRatePermDownSmall->get())
-        m_pRateSlider->sub(m_pRateDir->get() * m_dPermSmall / (100. * m_pRateRange->get()));
+        m_pRateSlider->set(m_pRateSlider->get() -
+                           m_pRateDir->get() * m_dPermSmall / (100. * m_pRateRange->get()));
 }
 
 void RateControl::slotControlRatePermUp(double)
 {
     // Adjusts temp rate up if button pressed
-    if (buttonRatePermUp->get())
-        m_pRateSlider->add(m_pRateDir->get() * m_dPerm / (100. * m_pRateRange->get()));
+    if (buttonRatePermUp->get()) {
+        m_pRateSlider->set(m_pRateSlider->get() +
+                           m_pRateDir->get() * m_dPerm / (100. * m_pRateRange->get()));
+    }
 }
 
 void RateControl::slotControlRatePermUpSmall(double)
 {
     // Adjusts temp rate up if button pressed
     if (buttonRatePermUpSmall->get())
-        m_pRateSlider->add(m_pRateDir->get() * m_dPermSmall / (100. * m_pRateRange->get()));
+        m_pRateSlider->set(m_pRateSlider->get() +
+                           m_pRateDir->get() * m_dPermSmall / (100. * m_pRateRange->get()));
 }
 
 void RateControl::slotControlRateTempDown(double)

=== removed file 'mixxx/src/engine/syncworker.cpp'
--- mixxx/src/engine/syncworker.cpp	2012-12-10 07:00:21 +0000
+++ mixxx/src/engine/syncworker.cpp	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-#include <QApplication>
-
-#include "engine/syncworker.h"
-
-#include "controlobject.h"
-#include "engine/engineworkerscheduler.h"
-
-SyncWorker::SyncWorker(EngineWorkerScheduler* pScheduler) {
-    pScheduler->bindWorker(this);
-    installEventFilter(this);
-}
-
-SyncWorker::~SyncWorker() {
-}
-
-#define MIXXXEVENT_SYNC ((QEvent::Type)(QEvent::User+4))
-bool SyncWorker::eventFilter(QObject* o, QEvent* e) {
-    if (e && e->type() == MIXXXEVENT_SYNC) {
-        ControlObject::sync();
-        return true;
-    }
-    return QObject::eventFilter(o,e);
-}
-
-void SyncWorker::run() {
-    // Notify the EngineWorkerScheduler that the work we scheduled is starting.
-    emit(workStarting(this));
-
-    QApplication::postEvent(this, new QEvent(MIXXXEVENT_SYNC));
-
-    // Notify the EngineWorkerScheduler that the work we did is done.
-    emit(workDone(this));
-}
-
-void SyncWorker::schedule() {
-    emit(workReady(this));
-}

=== removed file 'mixxx/src/engine/syncworker.h'
--- mixxx/src/engine/syncworker.h	2012-12-10 07:00:21 +0000
+++ mixxx/src/engine/syncworker.h	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-#ifndef SYNCWORKER_H
-#define SYNCWORKER_H
-
-#include <QObject>
-#include <QEvent>
-
-#include "engine/engineworker.h"
-
-class EngineWorkerScheduler;
-
-class SyncWorker : public EngineWorker {
-    Q_OBJECT
-  public:
-    explicit SyncWorker(EngineWorkerScheduler* pScheduler);
-    virtual ~SyncWorker();
-
-    void run();
-    void schedule();
-
-    bool eventFilter(QObject* o, QEvent* e);
-};
-
-#endif /* SYNCWORKER_H */

=== modified file 'mixxx/src/mixxx.cpp'
--- mixxx/src/mixxx.cpp	2013-05-13 00:05:03 +0000
+++ mixxx/src/mixxx.cpp	2013-05-17 16:35:30 +0000
@@ -401,8 +401,6 @@
     //  but do not set up controllers until the end of the application startup
     qDebug() << "Creating ControllerManager";
     m_pControllerManager = new ControllerManager(m_pConfig);
-    connect(m_pControllerManager, SIGNAL(syncControlSystem()),
-            this, SLOT(slotSyncControlSystem()));
 
     WaveformWidgetFactory::create();
     WaveformWidgetFactory::instance()->setConfig(m_pConfig);
@@ -1640,8 +1638,3 @@
     }
     return true;
 }
-
-void MixxxApp::slotSyncControlSystem() {
-    ScopedTimer t("MixxxApp::slotSyncControlSystem");
-    ControlObject::sync();
-}

=== modified file 'mixxx/src/mixxx.h'
--- mixxx/src/mixxx.h	2013-05-13 00:05:03 +0000
+++ mixxx/src/mixxx.h	2013-05-17 16:35:30 +0000
@@ -118,7 +118,6 @@
     void slotToCenterOfPrimaryScreen();
 
     void onNewSkinLoaded();
-    void slotSyncControlSystem();
 
   signals:
     void newSkinLoaded();

=== modified file 'mixxx/src/mixxxkeyboard.cpp'
--- mixxx/src/mixxxkeyboard.cpp	2012-12-24 10:58:09 +0000
+++ mixxx/src/mixxxkeyboard.cpp	2013-05-17 16:35:30 +0000
@@ -63,7 +63,7 @@
 
             if (pConfigKey)
             {
-                ControlObject::getControl(*pConfigKey)->queueFromMidi(MIDI_NOTE_ON, 1);
+                ControlObject::getControl(*pConfigKey)->setValueFromMidi(MIDI_NOTE_ON, 1);
                 // Add key to active key list
                 m_qActiveKeyList.append(QPair<int, ConfigKey *>(keyId,pConfigKey));
                 return true;
@@ -86,7 +86,7 @@
         for (int i = m_qActiveKeyList.size() - 1; i >= 0; i--) {
             if (m_qActiveKeyList[i].first == keyId) {
                 if(!autoRepeat) {
-                    ControlObject::getControl(*(m_qActiveKeyList[i].second))->queueFromMidi(MIDI_NOTE_OFF, 0);
+                    ControlObject::getControl(*(m_qActiveKeyList[i].second))->setValueFromMidi(MIDI_NOTE_OFF, 0);
                     m_qActiveKeyList.removeAt(i);
                 }
                 return true;

=== modified file 'mixxx/src/playermanager.cpp'
--- mixxx/src/playermanager.cpp	2013-05-07 05:10:11 +0000
+++ mixxx/src/playermanager.cpp	2013-05-17 16:35:30 +0000
@@ -1,5 +1,6 @@
 // playermanager.cpp
 // Created 6/1/2010 by RJ Ryan ([e-mail])
+#include <QMutexLocker>
 
 #include "playermanager.h"
 
@@ -23,6 +24,7 @@
                              SoundManager* pSoundManager,
                              EngineMaster* pEngine,
                              VinylControlManager* pVCManager) :
+        m_mutex(QMutex::Recursive),
         m_pConfig(pConfig),
         m_pSoundManager(pSoundManager),
         m_pEngine(pEngine),
@@ -35,11 +37,14 @@
         m_pCONumPreviewDecks(new ControlObject(ConfigKey("[Master]", "num_preview_decks"), true, true)) {
 
     connect(m_pCONumDecks, SIGNAL(valueChanged(double)),
-            this, SLOT(slotNumDecksControlChanged(double)));
+            this, SLOT(slotNumDecksControlChanged(double)),
+            Qt::DirectConnection);
     connect(m_pCONumSamplers, SIGNAL(valueChanged(double)),
-            this, SLOT(slotNumSamplersControlChanged(double)));
+            this, SLOT(slotNumSamplersControlChanged(double)),
+            Qt::DirectConnection);
     connect(m_pCONumPreviewDecks, SIGNAL(valueChanged(double)),
-            this, SLOT(slotNumPreviewDecksControlChanged(double)));
+            this, SLOT(slotNumPreviewDecksControlChanged(double)),
+            Qt::DirectConnection);
 
     // This is parented to the PlayerManager so does not need to be deleted
     SamplerBank* pSamplerBank = new SamplerBank(this);
@@ -58,6 +63,7 @@
 }
 
 PlayerManager::~PlayerManager() {
+    QMutexLocker locker(&m_mutex);
     // No need to delete anything because they are all parented to us and will
     // be destroyed when we are destroyed.
     m_players.clear();
@@ -73,6 +79,7 @@
 }
 
 void PlayerManager::bindToLibrary(Library* pLibrary) {
+    QMutexLocker locker(&m_mutex);
     connect(pLibrary, SIGNAL(loadTrackToPlayer(TrackPointer, QString, bool)),
             this, SLOT(slotLoadTrackToPlayer(TrackPointer, QString, bool)));
     connect(pLibrary, SIGNAL(loadTrack(TrackPointer)),
@@ -159,57 +166,65 @@
 }
 
 void PlayerManager::slotNumDecksControlChanged(double v) {
-    // First off, undo any changes to the control.
-    m_pCONumDecks->set(m_decks.size());
-
-    int num = v;
+    QMutexLocker locker(&m_mutex);
+    int num = (int)v;
     if (num < m_decks.size()) {
+        // The request was invalid -- reset the value.
+        m_pCONumDecks->set(m_decks.size());
         qDebug() << "Ignoring request to reduce the number of decks to" << num;
         return;
     }
 
     while (m_decks.size() < num) {
-        addDeck();
+        addDeckInner();
     }
 }
 
 void PlayerManager::slotNumSamplersControlChanged(double v) {
-    // First off, undo any changes to the control.
-    m_pCONumSamplers->set(m_samplers.size());
-
-    int num = v;
+    QMutexLocker locker(&m_mutex);
+    int num = (int)v;
     if (num < m_samplers.size()) {
+        // The request was invalid -- reset the value.
+        m_pCONumSamplers->set(m_samplers.size());
         qDebug() << "Ignoring request to reduce the number of samplers to" << num;
         return;
     }
 
     while (m_samplers.size() < num) {
-        addSampler();
+        addSamplerInner();
     }
 }
 
 void PlayerManager::slotNumPreviewDecksControlChanged(double v) {
-    // First off, undo any changes to the control.
-    m_pCONumPreviewDecks->set(m_preview_decks.size());
-
-    int num = v;
+    QMutexLocker locker(&m_mutex);
+    int num = (int)v;
     if (num < m_preview_decks.size()) {
+        // The request was invalid -- reset the value.
+        m_pCONumPreviewDecks->set(m_preview_decks.size());
         qDebug() << "Ignoring request to reduce the number of preview decks to" << num;
         return;
     }
 
     while (m_preview_decks.size() < num) {
-        addPreviewDeck();
+        addPreviewDeckInner();
     }
 }
 
-Deck* PlayerManager::addDeck() {
-    QString group = groupForDeck(numDecks());
-    int number = numDecks() + 1;
+void PlayerManager::addDeck() {
+    QMutexLocker locker(&m_mutex);
+    addDeckInner();
+    m_pCONumDecks->set((double)m_decks.count());
+}
+
+void PlayerManager::addDeckInner() {
+    // Do not lock m_mutex here.
+    QString group = groupForDeck(m_decks.count());
+    int number = m_decks.count() + 1;
 
     EngineChannel::ChannelOrientation orientation = EngineChannel::LEFT;
-    if (number % 2 == 0)
+    if (number % 2 == 0) {
         orientation = EngineChannel::RIGHT;
+    }
 
     Deck* pDeck = new Deck(this, m_pConfig, m_pEngine, orientation, group);
     if (m_pAnalyserQueue) {
@@ -220,7 +235,6 @@
     Q_ASSERT(!m_players.contains(group));
     m_players[group] = pDeck;
     m_decks.append(pDeck);
-    m_pCONumDecks->add(1);
 
     // Register the deck output with SoundManager (deck is 0-indexed to SoundManager)
     m_pSoundManager->registerOutput(
@@ -237,12 +251,17 @@
     EngineDeck* pEngineDeck = pDeck->getEngineDeck();
     m_pSoundManager->registerInput(
         AudioInput(AudioInput::VINYLCONTROL, 0, number-1), pEngineDeck);
-
-    return pDeck;
-}
-
-Sampler* PlayerManager::addSampler() {
-    QString group = groupForSampler(numSamplers());
+}
+
+void PlayerManager::addSampler() {
+    QMutexLocker locker(&m_mutex);
+    addSamplerInner();
+    m_pCONumSamplers->set(m_samplers.count());
+}
+
+void PlayerManager::addSamplerInner() {
+    // Do not lock m_mutex here.
+    QString group = groupForSampler(m_samplers.count());
 
     // All samplers are in the center
     EngineChannel::ChannelOrientation orientation = EngineChannel::CENTER;
@@ -256,13 +275,17 @@
     Q_ASSERT(!m_players.contains(group));
     m_players[group] = pSampler;
     m_samplers.append(pSampler);
-    m_pCONumSamplers->add(1);
-
-    return pSampler;
-}
-
-PreviewDeck* PlayerManager::addPreviewDeck() {
-    QString group = groupForPreviewDeck(numPreviewDecks());
+}
+
+void PlayerManager::addPreviewDeck() {
+    QMutexLocker locker(&m_mutex);
+    addPreviewDeckInner();
+    m_pCONumPreviewDecks->set(m_preview_decks.count());
+}
+
+void PlayerManager::addPreviewDeckInner() {
+    // Do not lock m_mutex here.
+    QString group = groupForPreviewDeck(m_preview_decks.count());
 
     // All preview decks are in the center
     EngineChannel::ChannelOrientation orientation = EngineChannel::CENTER;
@@ -276,11 +299,10 @@
     Q_ASSERT(!m_players.contains(group));
     m_players[group] = pPreviewDeck;
     m_preview_decks.append(pPreviewDeck);
-    m_pCONumPreviewDecks->add(1);
-    return pPreviewDeck;
 }
 
 BaseTrackPlayer* PlayerManager::getPlayer(QString group) const {
+    QMutexLocker locker(&m_mutex);
     if (m_players.contains(group)) {
         return m_players[group];
     }
@@ -289,6 +311,7 @@
 
 
 Deck* PlayerManager::getDeck(unsigned int deck) const {
+    QMutexLocker locker(&m_mutex);
     if (deck < 1 || deck > numDecks()) {
         qWarning() << "Warning PlayerManager::getDeck() called with invalid index: "
                    << deck;
@@ -298,6 +321,7 @@
 }
 
 PreviewDeck* PlayerManager::getPreviewDeck(unsigned int libPreviewPlayer) const {
+    QMutexLocker locker(&m_mutex);
     if (libPreviewPlayer < 1 || libPreviewPlayer > numPreviewDecks()) {
         qWarning() << "Warning PlayerManager::getPreviewDeck() called with invalid index: "
                    << libPreviewPlayer;
@@ -307,6 +331,7 @@
 }
 
 Sampler* PlayerManager::getSampler(unsigned int sampler) const {
+    QMutexLocker locker(&m_mutex);
     if (sampler < 1 || sampler > numSamplers()) {
         qWarning() << "Warning PlayerManager::getSampler() called with invalid index: "
                    << sampler;
@@ -316,6 +341,8 @@
 }
 
 void PlayerManager::slotLoadTrackToPlayer(TrackPointer pTrack, QString group, bool play) {
+    // Do not lock mutex in this method unless it is changed to access
+    // PlayerManager state.
     BaseTrackPlayer* pPlayer = getPlayer(group);
 
     if (pPlayer == NULL) {
@@ -344,31 +371,33 @@
     slotLoadToPlayer(location, groupForSampler(sampler-1));
 }
 
-void PlayerManager::slotLoadTrackIntoNextAvailableDeck(TrackPointer pTrack)
-{
+void PlayerManager::slotLoadTrackIntoNextAvailableDeck(TrackPointer pTrack) {
+    QMutexLocker locker(&m_mutex);
     QList<Deck*>::iterator it = m_decks.begin();
     while (it != m_decks.end()) {
         Deck* pDeck = *it;
         ControlObject* playControl =
                 ControlObject::getControl(ConfigKey(pDeck->getGroup(), "play"));
         if (playControl && playControl->get() != 1.) {
+            locker.unlock();
             pDeck->slotLoadTrack(pTrack, false);
-            break;
+            return;
         }
         it++;
     }
 }
 
-void PlayerManager::slotLoadTrackIntoNextAvailableSampler(TrackPointer pTrack)
-{
+void PlayerManager::slotLoadTrackIntoNextAvailableSampler(TrackPointer pTrack) {
+    QMutexLocker locker(&m_mutex);
     QList<Sampler*>::iterator it = m_samplers.begin();
     while (it != m_samplers.end()) {
         Sampler* pSampler = *it;
         ControlObject* playControl =
                 ControlObject::getControl(ConfigKey(pSampler->getGroup(), "play"));
         if (playControl && playControl->get() != 1.) {
+            locker.unlock();
             pSampler->slotLoadTrack(pTrack, false);
-            break;
+            return;
         }
         it++;
     }

=== modified file 'mixxx/src/playermanager.h'
--- mixxx/src/playermanager.h	2013-04-29 21:05:20 +0000
+++ mixxx/src/playermanager.h	2013-05-17 16:35:30 +0000
@@ -5,6 +5,7 @@
 #define PLAYERMANAGER_H
 
 #include <QList>
+#include <QMutex>
 
 #include "configobject.h"
 #include "trackinfoobject.h"
@@ -32,13 +33,13 @@
     virtual ~PlayerManager();
 
     // Add a deck to the PlayerManager
-    Deck* addDeck();
+    void addDeck();
 
     // Add a sampler to the PlayerManager
-    Sampler* addSampler();
+    void addSampler();
 
     // Add a PreviewDeck to the PlayerManager
-    PreviewDeck* addPreviewDeck();
+    void addPreviewDeck();
 
     // Return the number of players. Thread-safe.
     static unsigned int numDecks();
@@ -109,6 +110,19 @@
 
   private:
     TrackPointer lookupTrack(QString location);
+    // Must hold m_mutex before calling this method. Internal method that
+    // creates a new deck.
+    void addDeckInner();
+    // Must hold m_mutex before calling this method. Internal method that
+    // creates a new sampler.
+    void addSamplerInner();
+    // Must hold m_mutex before calling this method. Internal method that
+    // creates a new preview deck.
+    void addPreviewDeckInner();
+
+    // Used to protect access to PlayerManager state across threads.
+    mutable QMutex m_mutex;
+
     ConfigObject<ConfigValue>* m_pConfig;
     SoundManager* m_pSoundManager;
     EngineMaster* m_pEngine;

=== modified file 'mixxx/src/skin/legacyskinparser.cpp'
--- mixxx/src/skin/legacyskinparser.cpp	2013-05-01 12:42:34 +0000
+++ mixxx/src/skin/legacyskinparser.cpp	2013-05-17 16:35:30 +0000
@@ -272,16 +272,6 @@
             mainControl.slotSet(value);
         }
     }
-    // Force a sync to deliver the control change messages so they take effect
-    // before we start processing the skin. This is mostly just so that
-    // additional decks/samplers are created before we start creating widgets
-    // for them.
-
-    // HACK(XXX) This relies on the fact that the PlayerManager listens to
-    // changes to this control via a CO instead of a COTM. Otherwise the message
-    // would not get delivered until the Qt event loop delivered the
-    // message. rryan 10/2012
-    ControlObject::sync();
 
     ColorSchemeParser::setupLegacyColorSchemes(skinDocument, m_pConfig);
 

=== modified file 'mixxx/src/skin/propertybinder.cpp'
--- mixxx/src/skin/propertybinder.cpp	2013-01-04 16:07:55 +0000
+++ mixxx/src/skin/propertybinder.cpp	2013-05-17 16:35:30 +0000
@@ -34,6 +34,5 @@
     if (!m_pWidget->setProperty(propertyAscii.constData(), value)) {
         qDebug() << "Setting property" << m_propertyName << "to widget failed. Value:" << value;
     }
-    m_pConfig->set(m_pControlThreadMain->getControlObject()->getKey(),
-            QString::number(dValue));
+    m_pConfig->set(m_pControlThreadMain->getKey(), QString::number(dValue));
 }

=== modified file 'mixxx/src/sounddeviceportaudio.cpp'
--- mixxx/src/sounddeviceportaudio.cpp	2013-03-21 22:29:13 +0000
+++ mixxx/src/sounddeviceportaudio.cpp	2013-05-17 16:35:30 +0000
@@ -167,7 +167,7 @@
                         m_dSampleRate,
                         m_framesPerBuffer,
                         paClipOff, // Stream flags
-                        callback,    
+                        callback,
                         (void*) this); // pointer passed to the callback function
 
     if (err != paNoError)
@@ -329,7 +329,8 @@
     if (!m_undeflowUpdateCount) {
         if (statusFlags & (paOutputUnderflow | paInputOverflow)) {