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

[Sean M. Pappalardo]

[Sean M. Pappalardo (pegasus-renegadetech)]

MIDI script timers have been successfully added to the MIDI script engine, and tested on an SCS.3d using a light show script. (The venerable light show script first seen on YouTube has been updated to no longer run an endless loop! :) The light show can now be paused, restarted, and run without noticeably impacting Mixxx's performance.)

I respectfully request consideration of merging this in time for the 1.8 release for the following reasons:

1) The timer functionality has been added on to the MIDI script engine (as opposed to changing anything,) so the core functionality has not been altered
2) Good scratching performance requires the use of fixed-interval control sampling which is not possible without timers. This is one area where Mixxx is lagging its competitors and having it ready for 1.8 would help close the gap. (I plan to modify the common script scratching functions to make use of the timers (which won't take long) after this is merged, allowing all scripts that currently use the scratch.* common functions to take advantage of it immediately. (Some minor tweaks may be needed.))
3) Timers also allow script programmers to flash lights on MIDI controllers (such as when nearing the end of a track, setting a cue point (like CDJs,) or changing modes) without busy-wait loops which are inaccurate and have an adverse effect on Mixxx's playback.

[RJ Skerry-Ryan (rryan)]

Hey Sean,

Thanks for working on this. It looks like a feature that will provide needed flexibility to script writers. I've looked it over and I have a few comments.

On the primer timer:
- Why did you pick 20ms? Will a slower timer serve the same purpose of making the other timers work? (e.g. can we set the primer timer to something like an hour? a day?)
- Did you ever discover why startTimer() stops working unless the primer timer is created? It seems like this is either a bug in Qt or a bug in our code.

Honestly this is the most concerning part of this branch and I think it needs fixing. This means that a high resolution timer will always be executing for every MIDI device you plug in (one per script engine) even if your scripts aren't using timers (high-or-low resolution) at all.

First off, the approach is very clean (other than the primer timer) -- which I do like. I am concerned that a script could bring down Mixxx by creating 100 high resolution timers. The script engine thread could strangle the engine. (Also, MidiScriptEngine should set its thread priority lower.) We already have bad thread contention on single-CPU machines so this makes me worry. When you were implementing this design, did you put any thought into the alternate (less clean) approach we discussed where you would create one Qt script timer and run the script timers on that main timer? You would just keep track of the last time each timer got triggered and trigger the timer if the current time is greater than the previous time plus the timer's interval. What made you go with this approach rather than that one?

- Do you have any profiling output to support that this approach is not taxing?
- Have you experimented with malicious (or dumb) script writing to figure out just how many timers your machine can support before Mixxx performance is degraded? I'm very interested to see data like this for single-CPU low-power machines.

I also have some minor code comments:

~MidiScriptEngine()
- When calling stopTimer(), use a QMutableHashIterator and remove each key before calling stopTimer. You do hold the script engine lock, but it can't hurt to do it safer.

beginTimer()
- No bounds checking on the 'interval' variable (should at least be non-zero). Have you given any thought to preventing scripts from making high-resolution timers? (e.g. sub-10ms) I don't think that a script should be able to affect Mixxx's performance.

stopTimer()
- No validity checking on timerId variable. (Should check that the hash contains the timerId key first before calling stopTimer -- Qt doesn't specify its behavior if the timer id you pass is invalid, so you can only assume it crashes or asserts).

timerEvent()
- Please check that event.timerId() is in m_timers before indexing into the hash (would cause an assert and kill Mixxx). Suppose killTimer has a delayed effect or something and a timerEvent for a timer that was just killTimer'd can occur (Qt doesn't make any promises like this). You could run into a situation where the timer id is not in the hash. Better safe than sorry.

review: Needs Information

[Sean M. Pappalardo (pegasus-renegadetech)]

> On the primer timer:
> - Why did you pick 20ms? Will a slower timer serve the same purpose of making
> the other timers work? (e.g. can we set the primer timer to something like an
> hour? a day?)

No, since timers set up before exec() apparently block any other timers, forcing them to fire only up to as often as the shortest pre-exec() one. Also 20ms is the highest resolution that most platforms support. (Linux apparently supports higher, but I noticed a ~10% CPU usage increase at idle when I had it fire as often as possible (interval 0) on this 2.53GHz Celeron D.)

> - Did you ever discover why startTimer() stops working unless the primer timer
> is created? It seems like this is either a bug in Qt or a bug in our code.

Our code is straightforward. Unless the event loop/thread is somehow being set up incorrectly, I'm thinking it's Qt.

> Honestly this is the most concerning part of this branch and I think it needs
> fixing. This means that a high resolution timer will always be executing for
> every MIDI device you plug in (one per script engine) even if your scripts
> aren't using timers (high-or-low resolution) at all.

I agree. It bothers me a lot.

> First off, the approach is very clean (other than the primer timer) -- which I
> do like. I am concerned that a script could bring down Mixxx by creating 100
> high resolution timers. The script engine thread could strangle the engine.

That's possible, though Qt will refuse to set up a timer if the OS has reached its limit. But how do we decide what an acceptable upper bound is without limiting future expandability?

> (Also, MidiScriptEngine should set its thread priority lower.)

Done, set to QThread::LowPriority, though I worry a bit about responsiveness and scratching performance (until we implement that in the engine.)

> When you
> were implementing this design, did you put any thought into the alternate
> (less clean) approach we discussed where you would create one Qt script timer
> and run the script timers on that main timer?

Not really. I just wanted to see if the simplest design would work acceptably, and it does! :) Though I don't see how doing what you suggest would help much since you'd still need a high resolution timer running all the time.

> You would just keep track of the
> last time each timer got triggered and trigger the timer if the current time
> is greater than the previous time plus the timer's interval. What made you go
> with this approach rather than that one?

Well, the OS already handles that, (and probably better than I would) so why do the work again? And like I said above, I wanted to try the simplest method first (not knowing about the need for this primer timer.) That and QBasicTimer/QTimer operate using the same event loop mechanism. They just make timer management more convenient, at the cost of some overhead.

> - Do you have any profiling output to support that this approach is not
> taxing?

It IS taxing if the primer timer runs any more often. (I saw a 10% CPU increase on this 2.53GHz Celeron-D when I tried the primer at interval 0 (run every time there are no more events in the queue.)) That said, running it at 20ms caused only a slight aver...

review: Needs Resubmitting

[Adam Davison (adamdavison)]

This is mostly not my area of expertise but Sean I have one question. You mention that this is required for good scratching. Can you explain why this is the case? Surely ultimately for high performance scratching you want up to ~1ms precision which as you mention, operating system timers cannot provide. And in fact you aren't sampling the "velocity" of the midi wheels, you're getting discrete delta position numbers from the midi controller. Surely the best approach is to process these scratch deltas as they arrive in some way, not as part of a timer loop which necessarily introduces additional latency?

[Sean M. Pappalardo (pegasus-renegadetech)]

> This is mostly not my area of expertise but Sean I have one question. You
> mention that this is required for good scratching. Can you explain why this is
> the case?

I mean it's required in order to continue to do it in script. Ultimately we'll be doing it in the Engine, but that's a ways off and I'd like to get some improvement on this into 1.8.

> And in fact you aren't sampling the "velocity" of the midi wheels, you're
> getting discrete delta position numbers from the midi controller. Surely the
> best approach is to process these scratch deltas as they arrive in some way,

That's exactly my plan, using the alpha-beta filter code already in scratch.* script functions. But an alpha-beta filter is a time-sensitive one and without interval-based sampling, there is no way to tell it the wheel has stopped, so it's starved of data in that case instead of realizing that it needs to rapidly decelerate. (That's why in 1.7 it acts so screwy when you just hold your finger in one spot on the SCS.3d's red vinyl mode.)

[Adam Davison (adamdavison)]

> > And in fact you aren't sampling the "velocity" of the midi wheels, you're
> > getting discrete delta position numbers from the midi controller. Surely the
> > best approach is to process these scratch deltas as they arrive in some way,
>
> That's exactly my plan, using the alpha-beta filter code already in scratch.*
> script functions. But an alpha-beta filter is a time-sensitive one and without
> interval-based sampling, there is no way to tell it the wheel has stopped, so
> it's starved of data in that case instead of realizing that it needs to
> rapidly decelerate. (That's why in 1.7 it acts so screwy when you just hold
> your finger in one spot on the SCS.3d's red vinyl mode.)

Ok, so the timer basically just provides some kind of nothing-happened-in-this-tick signal to the filter. That all sounds reasonable.

Thanks,

Adam

[Sean M. Pappalardo (pegasus-renegadetech)]

Resubmitting for review.

I discovered that the primer timer was a hack and the real problem is that the MidiDevice thread was executing all of the script functions, including timer creation! (Timers must be created in the thread in which they're to fire, i.e. the MidiScriptEngine thread.)

I've untangled all of that and now the MidiScriptEngine takes care of loading, initializing, and shutting down all MIDI scripts, as it should. It and the MidiMapping communicate via signals so things happen in the correct order (the MidiMapping tells the MidiScriptEngine to do one of those tasks then waits on its signal to continue.) Timers now work perfectly as originally expected on Linux and Windows with no appreciable CPU increase (unless you run 3000 timers at once...which I tried, and Mixxx is still responsive up but you notice it going slower. :) )

(This should also help resolve any strange script engine crashes we'd seen in bug reports.)

review: Needs Resubmitting

[RJ Skerry-Ryan (rryan)]

Looking good Sean. Glad to see the primer timer is gone. I have a few comments / fixes.

MidiScriptEngine::MidiScriptEngine(...)

- Passing references to m_scriptFileNames and m_scriptFunctionPrefixes is not
  good. They are QList's, which are not thread safe. Two threads accessing a
  list at the same time will segfault. You should make these two lists arguments
  to the signals that deal with them and pass by value, not reference.

- On the diversity of callMidiScriptFunction signals and execute methods with
  multiple parameters: In the end we just make a QScriptValueList and we don't
  care about the individual types of the parameters. I say we just accept one
  signal for executing a script function: callMidiScriptFunction(QString name,
  QList<QVariant> arguments) and consolidate all the execute(...) methods into
  one execute(QString function, QList<QVariant> arguments); method.

MidiScriptEngine::gracefulShutdown()

- Need to hold the engine lock before calling m_connectedControls.clear()

MidiScriptEngine::loadScriptFile()

- As I mentioned, convert this to take m_rScriptFileNames as an argument instead
  of sharing it between the classes. Is there any problem I'm not seeing with doing it this way?

MidiScriptEngine::stopAllTimers()

- Please add comment to the top that the caller should hold the script lock.

MidiScriptEngine::timerEvent()

- Need to hold the lock to user m_timers. I know that this is technically safe,
  we're just going for overkill here :).

Overall

- qWarnings and qCritical - I really don't think these should anywhere in the
  script engine. Maybe it's ok for a script function that only happens on
  initialization -- but in the end no DJ cares about a syntax error more than
  s/he cares about Mixxx not going down in the middle of their set.

review: Needs Fixing

[lp:~mixxxdevelopers/mixxx/features_scriptTimers]

2273. By Sean M. Pappalardo on 2010-02-02

Addressed RJ's code review concerns:
- got rid of the reference passing between threads and replaced with value passing on signals (it's actually neater this way too)
- moved the lock in gracefulShutdown() to include clearing m_connectedControls
- added lock assert to stopAllTimers() too
- moved the lock in timerEvent to include m_timers[] access

2274. By Sean M. Pappalardo on 2010-02-03

- Made the midiDebug flag global in the MidiScriptEngine instead of asking the MidiDevice for it each time
- Replaced obsolete canEvaluate() with checkSyntax()
- Mixxx now shows friendly warning dialogs and no longer aborts on script errors (unless run with --midiDebug)

[Sean M. Pappalardo (pegasus-renegadetech)]

Another resubmit.

> - Passing references to m_scriptFileNames and m_scriptFunctionPrefixes is not
> good.

Fixed.

> I say we just accept one
> signal for executing a script function: callMidiScriptFunction(QString name,
> QList<QVariant> arguments) and consolidate all the execute(...) methods into
> one execute(QString function, QList<QVariant> arguments); method.

I agree, though right now the only thing that signals the MidiScriptEngine is MidiMapping and the existing two signals are all it needs. So I'm thinking we should defer this consolidation unless/until it ever becomes an issue. (Also, can you even send null QLists for situations where we want to execute a parameter-less function or a non-function piece of script code?)

> MidiScriptEngine::gracefulShutdown()
> - Need to hold the engine lock before calling m_connectedControls.clear()

Fixed.

> MidiScriptEngine::loadScriptFile()
> - As I mentioned, convert this to take m_rScriptFileNames as an argument
> instead of sharing it between the classes.

Done, works fine.

> MidiScriptEngine::stopAllTimers()
> - Please add comment to the top that the caller should hold the script lock.

Did you one better and asserted that the lock is held (kind of redundant since stopTimers() also checks, but whatever.)

> MidiScriptEngine::timerEvent()
> - Need to hold the lock to user m_timers.

Fixed.

> - qWarnings and qCritical - I really don't think these should anywhere in the
> script engine. Maybe it's ok for a script function that only happens on
> initialization -- but in the end no DJ cares about a syntax error more than
> s/he cares about Mixxx not going down in the middle of their set.

Agreed. I examined the various things that were qCriticals and discovered that QScriptEngine::canEvaluate() has been obsoleted. So those qCriticals have been removed. I added the checkSyntax() system in their place and I have it pop up qCriticals with the error details only if --midiDebug is enabled, otherwise it qDebugs the details and pops up a friendly qWarning which the user can acknowledge and continue to mix (though with the controller in a degraded state.) As for loops, only the first warning dialog comes up; all others are supressed until the first is acknowledged. (So the user will see one each time he does something that calls an offending function.) However, if the syntax error is discovered on file load, that warning dialog shows up only once (each time the script file is (re)loaded) and informs the user that the offending script will be disabled.

One thing to note about allowing the user to continue on a script error: the offending function aborts on the statement that caused the exception, so the rest of the function doesn't execute and could leave the controller and script global variables in an indeterminate state (for example a mode change could have happened but the LEDs didn't get updated to show it.)

review: Needs Resubmitting

[lp:~mixxxdevelopers/mixxx/features_scriptTimers]

2275. By Sean M. Pappalardo on 2010-02-11

Merging from trunk

[Sean M. Pappalardo (pegasus-renegadetech)]

Resubmitting after trunk merge (seeing if it realizes I resolved the SConscript "conflict.")

Also, confirmed that the fixes in this branch eliminate the segfault-on-close 90% of the time in Windows resulting from a qWarning trying to appear to tell us of a race condition "[Main]: QWaitCondition: Destroyed while threads are still waiting." This must've been related to MidiScriptEngine threads since it doesn't happen in this branch.

review: Needs Resubmitting

[Sean M. Pappalardo (pegasus-renegadetech)]

One tester confirmed that this appears to indeed fix a scriptEngine crash from 1.7, though I'd have to back-port to be sure. I'm not sure that's worth the time though. https://bugs.launchpad.net/mixxx/+bug/493793/comments/30

[lp:~mixxxdevelopers/mixxx/features_scriptTimers]

2276. By Sean M. Pappalardo on 2010-02-22

- Removed _exit() hack for Windows
- Added "shutdown complete" message for closure

2277. By Sean M. Pappalardo on 2010-02-23

Updated from trunk

[Sean M. Pappalardo (pegasus-renegadetech)]

err https://bugs.launchpad.net/mixxx/+bug/493793/comments/33

[lp:~mixxxdevelopers/mixxx/features_scriptTimers]

2278. By Sean M. Pappalardo on 2010-03-04

Merging from trunk

2279. By Sean M. Pappalardo on 2010-03-05

Merging from trunk

2280. By Sean M. Pappalardo on 2010-03-20

Mo' comments

2281. By Sean M. Pappalardo on 2010-03-20

Merging from trunk again

[Albert Santoni (gamegod)]

> Another resubmit.
>
> > - Passing references to m_scriptFileNames and m_scriptFunctionPrefixes is
> not
> > good.
>
> Fixed.
>
> > I say we just accept one
> > signal for executing a script function: callMidiScriptFunction(QString
> name,
> > QList<QVariant> arguments) and consolidate all the execute(...) methods
> into
> > one execute(QString function, QList<QVariant> arguments); method.
>
> I agree, though right now the only thing that signals the MidiScriptEngine is
> MidiMapping and the existing two signals are all it needs. So I'm thinking we
> should defer this consolidation unless/until it ever becomes an issue. (Also,
> can you even send null QLists for situations where we want to execute a
> parameter-less function or a non-function piece of script code?)
>
> > MidiScriptEngine::gracefulShutdown()
> > - Need to hold the engine lock before calling m_connectedControls.clear()
>
> Fixed.
>
> > MidiScriptEngine::loadScriptFile()
> > - As I mentioned, convert this to take m_rScriptFileNames as an argument
> > instead of sharing it between the classes.
>
> Done, works fine.
>
> > MidiScriptEngine::stopAllTimers()
> > - Please add comment to the top that the caller should hold the script lock.
>
> Did you one better and asserted that the lock is held (kind of redundant since
> stopTimers() also checks, but whatever.)
>
> > MidiScriptEngine::timerEvent()
> > - Need to hold the lock to user m_timers.
>
> Fixed.
>
> > - qWarnings and qCritical - I really don't think these should anywhere in
> the
> > script engine. Maybe it's ok for a script function that only happens on
> > initialization -- but in the end no DJ cares about a syntax error more
> than
> > s/he cares about Mixxx not going down in the middle of their set.
>
> Agreed. I examined the various things that were qCriticals and discovered that
> QScriptEngine::canEvaluate() has been obsoleted. So those qCriticals have been
> removed. I added the checkSyntax() system in their place and I have it pop up
> qCriticals with the error details only if --midiDebug is enabled, otherwise it
> qDebugs the details and pops up a friendly qWarning which the user can
> acknowledge and continue to mix (though with the controller in a degraded
> state.) As for loops, only the first warning dialog comes up; all others are
> supressed until the first is acknowledged. (So the user will see one each time
> he does something that calls an offending function.) However, if the syntax
> error is discovered on file load, that warning dialog shows up only once (each
> time the script file is (re)loaded) and informs the user that the offending
> script will be disabled.
>
> One thing to note about allowing the user to continue on a script error: the
> offending function aborts on the statement that caused the exception, so the
> rest of the function doesn't execute and could leave the controller and script
> global variables in an indeterminate state (for example a mode change could
> have happened but the LEDs didn't get updated to show it.)

Sounds like you should give an option to reload the script when there's an exception. I'd rather have my controller lose whatever mode it's...

[Albert Santoni (gamegod)]

How should I be testing this code? The scratching on the SCS.3d seems asymmetric to me in the branch, as in stabbing forwards and backwards go at different rates.

There's a lot of great code here, I think you've done a great job with the script engine overall and you should be very proud of it. :)

The only inconsistency in the code I've found (so far) is in MidiScriptEngine::timerEvent(QTimerEvent *event). In the first "if" statement, you access m_timers without holding the script engine lock first. In every other case where m_timers is accessed in the midiscriptengine.cpp, the lock is always held first. So I would move the m_scriptEngineLock.lock() call that's already in the function right to the start, and then make sure you unlock it before you return in that if statement.

Otherwise, looking good to me...

Thanks!
Albert

review: Needs Fixing

[RJ Skerry-Ryan (rryan)]

I agree with Albert's timerEvent comment. I committed a fix and I re-reviewed the code. It all look good to me, so I'm marking approved. I'll let you do the honors Sean :).

review: Approve

[lp:~mixxxdevelopers/mixxx/features_scriptTimers]

2282. By RJ Skerry-Ryan on 2010-03-24

Move lock in MidiScriptEngine::timerEvent to resolve thread-safety issue.

=== modified file 'mixxx/res/midi/midi-mappings-scripts.js'
--- mixxx/res/midi/midi-mappings-scripts.js	2010-03-06 21:32:16 +0000
+++ mixxx/res/midi/midi-mappings-scripts.js	2010-03-24 04:40:48 +0000
@@ -239,7 +239,7 @@
 
 // The actual alpha-beta filter
 scratch.filter = function (currentDeck, controlValue, revtime, alpha, beta) {
-    // ------------- Thanks to Radiomark (of Xwax) for the info for below ------------------------
+    // ------------- Thanks to Mark Hills of Xwax (http://www.xwax.co.uk) for the info for below ------------------------
     
     // ideal position = (initial_p + (y - x) / 128 * 1.8)
     var ideal_p = scratch.variables["initialTrackPos"] + (controlValue - scratch.variables["initialControlValue"]) / 128 * revtime;

=== modified file 'mixxx/src/main.cpp'
--- mixxx/src/main.cpp	2010-03-11 12:14:05 +0000
+++ mixxx/src/main.cpp	2010-03-24 04:40:48 +0000
@@ -351,6 +351,10 @@
     
     delete mixxx;
     
+	qDebug() << "Mixxx shutdown complete.";
+
+	// Don't make any more output after this
+	//	or mixxx.log will get clobbered!
     if(Logfile.isOpen())
 	Logfile.close();
     

=== modified file 'mixxx/src/midi/mididevice.cpp'
--- mixxx/src/midi/mididevice.cpp	2009-11-26 06:15:01 +0000
+++ mixxx/src/midi/mididevice.cpp	2010-03-24 04:40:48 +0000
@@ -210,11 +210,10 @@
         //to the device. (sendShortMessage() would try to lock m_mutex...)
         locker.unlock();
 
-        if (!m_pMidiMapping->getMidiScriptEngine()->execute(configKey.item, channel, 
-                                                            control, value, status, 
-                                                            mixxxControl.getControlObjectGroup())) {
-            qDebug() << "MidiDevice: Invalid script function" << configKey.item;
-        }
+        // This needs to be a signal because the MIDI Script Engine thread must execute
+        //  script functions, not this MidiDevice one
+        emit(callMidiScriptFunction(configKey.item, channel, control, value, status, 
+                                mixxxControl.getControlObjectGroup()));
         return;
     }
 #endif

=== modified file 'mixxx/src/midi/mididevice.h'
--- mixxx/src/midi/mididevice.h	2009-11-26 06:15:01 +0000
+++ mixxx/src/midi/mididevice.h	2010-03-24 04:40:48 +0000
@@ -71,6 +71,8 @@
 
     signals:
         void midiEvent(MidiMessage message);
+        void callMidiScriptFunction(QString function, char channel, char control, char value, MidiStatusByte status, QString group);
+
     protected:
         /** Verbose device name, in format "[index]. [device name]". Suitable for display in GUI. */
         QString m_strDeviceName;

=== modified file 'mixxx/src/midi/midimapping.cpp'
--- mixxx/src/midi/midimapping.cpp	2010-01-05 03:05:02 +0000
+++ mixxx/src/midi/midimapping.cpp	2010-03-24 04:40:48 +0000
@@ -47,6 +47,8 @@
         qDebug() << "Creating new MIDI presets directory" << BINDINGS_PATH;
         QDir().mkpath(BINDINGS_PATH);
     }
+    // So we can signal the MidiScriptEngine and pass a QList
+    qRegisterMetaType<QList<QString> >("QList<QString>");
 
     //Q_ASSERT(outputMidiDevice);
 
@@ -85,6 +87,7 @@
 
     m_pScriptEngine->moveToThread(m_pScriptEngine);
 
+    // Let the script engine tell us when it's done with each task
     connect(m_pScriptEngine, SIGNAL(initialized()),
             this, SLOT(slotScriptEngineReady()),
             Qt::DirectConnection);
@@ -94,58 +97,53 @@
     m_scriptEngineInitializedCondition.wait(&m_scriptEngineInitializedMutex);
     m_scriptEngineInitializedMutex.unlock();
 
+    // Allow this object to signal the MidiScriptEngine to load the list of script files
+    connect(this, SIGNAL(loadMidiScriptFiles(QList<QString>)), m_pScriptEngine, SLOT(loadScriptFiles(QList<QString>)));
+    // Allow this object to signal the MidiScriptEngine to run the initialization
+    //  functions in the loaded scripts
+    connect(this, SIGNAL(initMidiScripts(QList<QString>)), m_pScriptEngine, SLOT(initializeScripts(QList<QString>)));
+    // Allow this object to signal the MidiScriptEngine to run its shutdown routines
+    connect(this, SIGNAL(shutdownMidiScriptEngine(QList<QString>)), m_pScriptEngine, SLOT(gracefulShutdown(QList<QString>)));
+
+    // Allow this object to signal the MidiScriptEngine to call functions
+    connect(this, SIGNAL(callMidiScriptFunction(QString)),
+            m_pScriptEngine, SLOT(execute(QString)));
+    connect(this, SIGNAL(callMidiScriptFunction(QString, QString)),
+            m_pScriptEngine, SLOT(execute(QString, QString)));
 }
 
 void MidiMapping::loadScriptCode() {
     QMutexLocker Locker(&m_mappingLock);
-
-    ConfigObject<ConfigValue> *config = new ConfigObject<ConfigValue>(QDir::homePath().append("/").append(SETTINGS_PATH).append(SETTINGS_FILE));
-
-    qDebug() << "MidiMapping: Loading & evaluating all MIDI script code";
-
-    QListIterator<QString> it(m_pScriptFileNames);
-    while (it.hasNext()) {
-        QString curScriptFileName = it.next();
-        m_pScriptEngine->evaluate(config->getConfigPath().append("midi/").append(curScriptFileName));
-
-        if(m_pScriptEngine->hasErrors(curScriptFileName)) {
-            qDebug() << "Errors occured while loading " << curScriptFileName;
-        }
+    if(m_pScriptEngine) {
+        m_scriptEngineInitializedMutex.lock();
+        // Tell the script engine to run the init function in all loaded scripts
+        emit(loadMidiScriptFiles(m_scriptFileNames));
+        // Wait until it's done
+        m_scriptEngineInitializedCondition.wait(&m_scriptEngineInitializedMutex);
+        m_scriptEngineInitializedMutex.unlock();
     }
 }
 
 void MidiMapping::initializeScripts() {
     QMutexLocker Locker(&m_mappingLock);
     if(m_pScriptEngine) {
-        // Call each script's init function if it exists
-        QListIterator<QString> prefixIt(m_pScriptFunctionPrefixes);
-        while (prefixIt.hasNext()) {
-            QString initName = prefixIt.next();
-            if (initName!="") {
-                initName.append(".init");
-                qDebug() << "MidiMapping: Executing" << initName;
-                if (!m_pScriptEngine->execute(initName, m_deviceName))
-                    qWarning() << "MidiMapping: No" << initName << "function in script";
-            }
-        }
-    }
+        m_scriptEngineInitializedMutex.lock();
+        // Tell the script engine to run the init function in all loaded scripts
+        emit(initMidiScripts(m_scriptFunctionPrefixes));
+        // Wait until it's done
+        m_scriptEngineInitializedCondition.wait(&m_scriptEngineInitializedMutex);
+        m_scriptEngineInitializedMutex.unlock();
+    }    
 }
 
 void MidiMapping::shutdownScriptEngine() {
     QMutexLocker Locker(&m_mappingLock);
     if(m_pScriptEngine) {
-        // Call each script's shutdown function if it exists
-        QListIterator<QString> prefixIt(m_pScriptFunctionPrefixes);
-        while (prefixIt.hasNext()) {
-            QString shutName = prefixIt.next();
-            if (shutName!="") {
-                shutName.append(".shutdown");
-                qDebug() << "MidiMapping: Executing" << shutName;
-                if (!m_pScriptEngine->execute(shutName))
-                    qWarning() << "MidiMapping: No" << shutName << "function in script";
-            }
-        }
-        qDebug() << "MidiMapping: Deleting MIDI script engine...";
+        // Tell the script engine to do its shutdown sequence
+        emit(shutdownMidiScriptEngine(m_scriptFunctionPrefixes));
+        // ...and wait for it to finish
+        m_pScriptEngine->wait();
+        
         MidiScriptEngine *engine = m_pScriptEngine;
         m_pScriptEngine = NULL;
         delete engine;
@@ -484,8 +482,8 @@
    -------- ------------------------------------------------------ */
 void MidiMapping::addScriptFile(QString filename, QString functionprefix) {
     QMutexLocker Locker(&m_mappingLock);
-    m_pScriptFileNames.append(filename);
-    m_pScriptFunctionPrefixes.append(functionprefix);
+    m_scriptFileNames.append(filename);
+    m_scriptFunctionPrefixes.append(functionprefix);
 }
 #endif
 
@@ -539,8 +537,8 @@
     m_mappingLock.lock();
 
 #ifdef __MIDISCRIPT__
-    m_pScriptFileNames.clear();
-    m_pScriptFunctionPrefixes.clear();
+    m_scriptFileNames.clear();
+    m_scriptFunctionPrefixes.clear();
 #endif
 
     // For each controller in the DOM
@@ -753,15 +751,15 @@
     controller.appendChild(scriptFiles);
 
 
-    for (int i = 0; i < m_pScriptFileNames.count(); i++) {
-//         qDebug() << "MidiMapping: writing script block for" << m_pScriptFileNames[i];
-        QString filename = m_pScriptFileNames[i];
+    for (int i = 0; i < m_scriptFileNames.count(); i++) {
+//         qDebug() << "MidiMapping: writing script block for" << m_scriptFileNames[i];
+        QString filename = m_scriptFileNames[i];
 
 
         //Don't need to write anything for the required mapping file.
         if (filename != REQUIRED_SCRIPT_FILE) {
             qDebug() << "MidiMapping: writing script block for" << filename;
-            QString functionPrefix = m_pScriptFunctionPrefixes[i];
+            QString functionPrefix = m_scriptFunctionPrefixes[i];
             QDomElement scriptFile = doc.createElement("file");
 
 

=== modified file 'mixxx/src/midi/midimapping.h'
--- mixxx/src/midi/midimapping.h	2009-11-25 02:31:11 +0000
+++ mixxx/src/midi/midimapping.h	2010-03-24 04:40:48 +0000
@@ -111,6 +111,11 @@
     void midiLearningStarted();
     void midiLearningFinished(MidiMessage);
     void midiLearningFinished();
+    void callMidiScriptFunction(QString);
+    void callMidiScriptFunction(QString, QString);
+    void loadMidiScriptFiles(QList<QString>);
+    void initMidiScripts(QList<QString>);
+    void shutdownMidiScriptEngine(QList<QString>);
 
 private:
     int internalNumInputMidiMessages();
@@ -142,8 +147,8 @@
     /** Actually loads script code from the files in the list */
     void loadScriptCode();
 
-    QList<QString> m_pScriptFileNames;
-    QList<QString> m_pScriptFunctionPrefixes;
+    QList<QString> m_scriptFileNames;
+    QList<QString> m_scriptFunctionPrefixes;
     MidiScriptEngine *m_pScriptEngine;
 
     QMutex m_scriptEngineInitializedMutex;

=== modified file 'mixxx/src/midi/midimessage.cpp'
--- mixxx/src/midi/midimessage.cpp	2009-09-01 15:33:21 +0000
+++ mixxx/src/midi/midimessage.cpp	2010-03-24 04:40:48 +0000
@@ -7,6 +7,7 @@
 {
     //Register this class with QT so we can use this bad boy in signals/slots.
     qRegisterMetaType<MidiMessage>("MidiMessage");
+    qRegisterMetaType<MidiStatusByte>("MidiStatusByte");
 
     m_midiStatusByte = status;
     m_midiNo = midino;

=== modified file 'mixxx/src/midi/midiscriptengine.cpp'
--- mixxx/src/midi/midiscriptengine.cpp	2010-02-22 23:13:52 +0000
+++ mixxx/src/midi/midiscriptengine.cpp	2010-03-24 04:40:48 +0000
@@ -20,7 +20,7 @@
 #include "controlobjectthread.h"
 #include "mididevice.h"
 #include "midiscriptengine.h"
-
+// #include <QScriptSyntaxCheckResult>
 
 #ifdef _MSC_VER
 #include <float.h>  // for _isnan() on VC++
@@ -38,16 +38,6 @@
 
 MidiScriptEngine::~MidiScriptEngine() {
 
-    // Stop processing the event loop and terminate the thread.
-    quit();
-
-    // Clear the m_connectedControls hash so we stop responding
-    // to signals.
-    m_connectedControls.clear();
-
-    // Wait for the thread to terminate
-    wait();
-
     // Delete the script engine, first clearing the pointer so that
     // other threads will not get the dead pointer after we delete it.
     if(m_pEngine != NULL) {
@@ -56,6 +46,41 @@
         engine->deleteLater();
     }
 
+}
+
+/* -------- ------------------------------------------------------
+Purpose: Shuts down MIDI scripts in an orderly fashion
+            (stops timers then executes shutdown functions)
+Input:   -
+Output:  -
+-------- ------------------------------------------------------ */
+void MidiScriptEngine::gracefulShutdown(QList<QString> scriptFunctionPrefixes) {
+    qDebug() << "MidiScriptEngine shutting down...";
+    m_scriptEngineLock.lock();
+    // Clear the m_connectedControls hash so we stop responding
+    // to signals.
+    m_connectedControls.clear();
+
+    // Disconnect the function call signal
+    disconnect(m_pMidiDevice, SIGNAL(callMidiScriptFunction(QString, char, char,
+                                                            char, MidiStatusByte, QString)),
+                                this, SLOT(execute(QString, char, char, char, MidiStatusByte, QString)));
+
+    // Stop all timers
+    stopAllTimers();
+
+    // Call each script's shutdown function if it exists
+    QListIterator<QString> prefixIt(scriptFunctionPrefixes);
+    while (prefixIt.hasNext()) {
+        QString shutName = prefixIt.next();
+        if (shutName!="") {
+            shutName.append(".shutdown");
+            if (m_midiDebug) qDebug() << "MidiScriptEngine: Executing" << shutName;
+            if (!internalExecute(shutName))
+                qWarning() << "MidiScriptEngine: No" << shutName << "function in script";
+        }
+    }
+
     // Free all the control object threads
     QList<ConfigKey> keys = m_controlCache.keys();
     QList<ConfigKey>::iterator it = keys.begin();
@@ -63,12 +88,14 @@
     while(it != end) {
         ConfigKey key = *it;
         ControlObjectThread *cot = m_controlCache.take(key);
-        if(cot != NULL) {
-            delete cot;
-        }
+        delete cot;
         it++;
     }
 
+    m_scriptEngineLock.unlock();
+
+    // Stop processing the event loop and terminate the thread.
+    quit();
 }
 
 bool MidiScriptEngine::isReady() {
@@ -95,11 +122,73 @@
     // 'engine'.
     QScriptValue engineGlobalObject = m_pEngine->globalObject();
     engineGlobalObject.setProperty("engine", m_pEngine->newQObject(this));
+
+    // Make the MidiDevice instance available to scripts as
+    // 'midi'.
     if (m_pMidiDevice)
         engineGlobalObject.setProperty("midi", m_pEngine->newQObject(m_pMidiDevice));
 
-}
-
+    // Allow the MidiDevice to signal script function calls
+    connect(m_pMidiDevice, SIGNAL(callMidiScriptFunction(QString, char, char,
+                                                char, MidiStatusByte, QString)),
+            this, SLOT(execute(QString, char, char, char, MidiStatusByte, QString)));
+}
+
+/* -------- ------------------------------------------------------
+   Purpose: Load all script files given in the shared list
+   Input:   -
+   Output:  -
+   -------- ------------------------------------------------------ */
+void MidiScriptEngine::loadScriptFiles(QList<QString> scriptFileNames) {
+
+    // Set the Midi Debug flag
+    if (m_pMidiDevice)
+        m_midiDebug = m_pMidiDevice->midiDebugging();
+
+    qDebug() << "MidiScriptEngine: Loading & evaluating all MIDI script code";
+
+    ConfigObject<ConfigValue> *config = new ConfigObject<ConfigValue>(QDir::homePath().append("/").append(SETTINGS_PATH).append(SETTINGS_FILE));
+
+    QString scriptPath = config->getConfigPath().append("midi/");
+    delete config;
+
+    QListIterator<QString> it(scriptFileNames);
+    m_scriptEngineLock.lock();
+    while (it.hasNext()) {
+        QString curScriptFileName = it.next();
+        safeEvaluate(scriptPath+curScriptFileName);
+
+        if(m_scriptErrors.contains(curScriptFileName)) {
+            qDebug() << "Errors occured while loading " << curScriptFileName;
+        }
+    }
+
+    m_scriptEngineLock.unlock();
+    emit(initialized());
+}
+
+/* -------- ------------------------------------------------------
+   Purpose: Run the initialization function for each loaded script
+                if it exists
+   Input:   -
+   Output:  -
+   -------- ------------------------------------------------------ */
+void MidiScriptEngine::initializeScripts(QList<QString> scriptFunctionPrefixes) {
+    m_scriptEngineLock.lock();
+
+    QListIterator<QString> prefixIt(scriptFunctionPrefixes);
+    while (prefixIt.hasNext()) {
+        QString initName = prefixIt.next();
+            if (initName!="") {
+                initName.append(".init");
+            if (m_midiDebug) qDebug() << "MidiScriptEngine: Executing" << initName;
+            if (!safeExecute(initName, m_pMidiDevice->getName()))
+                qWarning() << "MidiScriptEngine: No" << initName << "function in script";
+        }
+    }
+    m_scriptEngineLock.unlock();
+    emit(initialized());
+}
 
 /* -------- ------------------------------------------------------
    Purpose: Create the MidiScriptEngine object (so it is owned in this
@@ -111,7 +200,8 @@
     unsigned static id = 0; //the id of this thread, for debugging purposes //XXX copypasta (should factor this out somehow), -kousu 2/2009
     QThread::currentThread()->setObjectName(QString("MidiScriptEngine %1").arg(++id));
 
-    //qDebug() << QString("----------------------------------MidiScriptEngine: Run Thread ID=%1").arg(QThread::currentThreadId(),0,16);
+    // Prevent the script engine from strangling other parts of Mixxx
+    QThread::currentThread()->setPriority(QThread::LowPriority);
 
     m_scriptEngineLock.lock();
     initializeScriptEngine();
@@ -143,6 +233,7 @@
 bool MidiScriptEngine::execute(QString function) {
     m_scriptEngineLock.lock();
     bool ret = safeExecute(function);
+    if (!ret) qDebug() << "MidiScriptEngine: Invalid script function" << function;
     m_scriptEngineLock.unlock();
     return ret;
 }
@@ -155,6 +246,7 @@
 bool MidiScriptEngine::execute(QString function, QString data) {
     m_scriptEngineLock.lock();
     bool ret = safeExecute(function, data);
+    if (!ret) qDebug() << "MidiScriptEngine: Invalid script function" << function;
     m_scriptEngineLock.unlock();
     return ret;
 }
@@ -170,6 +262,7 @@
                                QString group) {
     m_scriptEngineLock.lock();
     bool ret = safeExecute(function, channel, control, value, status, group);
+    if (!ret) qDebug() << "MidiScriptEngine: Invalid script function" << function;
     m_scriptEngineLock.unlock();
     return ret;
 }
@@ -182,22 +275,79 @@
 bool MidiScriptEngine::safeExecute(QString function) {
     //qDebug() << QString("MidiScriptEngine: Exec1 Thread ID=%1").arg(QThread::currentThreadId(),0,16);
 
-    if(m_pEngine == NULL) {
-        return false;
-    }
-
-    if (!m_pEngine->canEvaluate(function)) {
-        qCritical() << "MidiScriptEngine: ?Syntax error in function " << function;
-        return false;
-    }
+    if(m_pEngine == NULL)
+        return false;
 
     QScriptValue scriptFunction = m_pEngine->evaluate(function);
 
-    if (checkException()) return false;
-    if (!scriptFunction.isFunction()) return false;
-
-    scriptFunction.call(QScriptValue());
-    if (checkException()) return false;
+    if (checkException())
+        return false;
+
+    if (!scriptFunction.isFunction())
+        return false;
+
+    scriptFunction.call(QScriptValue());
+    if (checkException())
+        return false;
+
+    return true;
+}
+
+
+/* -------- ------------------------------------------------------
+Purpose: Evaluate & run script code
+Input:   Code string
+Output:  false if an exception
+-------- ------------------------------------------------------ */
+bool MidiScriptEngine::internalExecute(QString scriptCode) {
+    // A special version of safeExecute since we're evaluating strings, not actual functions
+    //  (execute() would print an error that it's not a function every time a timer fires.)
+    if(m_pEngine == NULL)
+        return false;
+
+    // Check syntax
+    QScriptSyntaxCheckResult result = m_pEngine->checkSyntax(scriptCode);
+    QString error="";
+    switch (result.state()) {
+        case (QScriptSyntaxCheckResult::Valid): break;
+        case (QScriptSyntaxCheckResult::Intermediate):
+            error = "Incomplete code";
+            break;
+        case (QScriptSyntaxCheckResult::Error):
+            error = "Syntax error";
+            break;
+    }
+    if (error!="") {
+        error = QString("%1: %2 at line %3, column %4 of script code:\n%5\n")
+        .arg(error)
+        .arg(result.errorMessage())
+        .arg(result.errorLineNumber())
+        .arg(result.errorColumnNumber())
+        .arg(scriptCode);
+
+        if (m_midiDebug) qCritical() << "MidiScriptEngine:" << error;
+        else {
+            qDebug() << "MidiScriptEngine:" << error;
+            qWarning() << "There was an error in a MIDI script."
+                          "\nA control you just used is not working properly and you may experience erratic behavior."
+                          "\nCheck the console or mixxx.log file for details.";
+        }
+        return false;
+    }
+
+    QScriptValue scriptFunction = m_pEngine->evaluate(scriptCode);
+
+    if (checkException())
+        return false;
+
+    // If it's not a function, we're done.
+    if (!scriptFunction.isFunction())
+        return true;
+
+    // If it does happen to be a function, call it.
+    scriptFunction.call(QScriptValue());
+    if (checkException())
+        return false;
 
     return true;
 }
@@ -214,11 +364,6 @@
         return false;
     }
 
-    if (!m_pEngine->canEvaluate(function)) {
-        qCritical() << "MidiScriptEngine: ?Syntax error in function " << function;
-        return false;
-    }
-
     QScriptValue scriptFunction = m_pEngine->evaluate(function);
 
     if (checkException())
@@ -250,11 +395,6 @@
         return false;
     }
 
-    if (!m_pEngine->canEvaluate(function)) {
-        qCritical() << "MidiScriptEngine: ?Syntax error in function " << function;
-        return false;
-    }
-
     QScriptValue scriptFunction = m_pEngine->evaluate(function);
 
     if (checkException())
@@ -296,15 +436,22 @@
         error << filename << errorMessage << QString(line);
         m_scriptErrors.insert(filename, error);
 
-        qCritical() << "MidiScriptEngine uncaught exception : "
-                    << errorMessage
-                    << "at " << filename << " line"
-                    << line;
-        // qCritical() << "MidiScriptEngine: uncaught exception"
-        //             << m_pEngine->uncaughtException().toString()
-        //             << "\nBacktrace:\n"
-        //             << m_pEngine->uncaughtExceptionBacktrace();
-
+        if (m_midiDebug)
+            qCritical() << "MidiScriptEngine: uncaught exception:"
+                        << errorMessage
+                        << "in" << filename << "at line"
+                        << line
+                        << "\nBacktrace:\n"
+                        << backtrace;
+        else {
+            qDebug() << "MidiScriptEngine WARNING: uncaught exception:"
+                         << errorMessage
+                         << "in" << filename << "at line"
+                         << line;
+            qWarning() << "There was a problem with a MIDI script."
+                          "\nA control you just used is not working properly and you may experience erratic behavior."
+                          "\nCheck the console or mixxx.log file for details.";
+        }
         return true;
     }
     return false;
@@ -331,7 +478,8 @@
 
 //     qDebug() << "MidiScriptEngine: m_scriptCode=" << m_scriptCode;
 
-    qDebug() << "MidiScriptEngine:" << codeLines.count() << "lines of code being searched for functions";
+    if (m_midiDebug)
+        qDebug() << "MidiScriptEngine:" << codeLines.count() << "lines of code being searched for functions";
 
     // grep 'function' midi/midi-mappings-scripts.js|grep -i '(msg)'|sed -e 's/function \(.*\)(msg).*/\1/i' -e 's/[= ]//g'
     QRegExp rx("*.*function*(*)*");    // Find all lines with function names in them
@@ -345,16 +493,13 @@
 
         if (line.indexOf('#') != 0 && line.indexOf("//") != 0) {    // ignore commented out lines
             QStringList field = line.split(" ");
-            if (m_pMidiDevice && m_pMidiDevice->midiDebugging())
-                qDebug() << "MidiScriptEngine: Found function:" << field[0]
-                         << "at line" << position;
-//             functionList.append(field[0]);
+            if (m_midiDebug) qDebug() << "MidiScriptEngine: Found function:" << field[0]
+                                      << "at line" << position;
             m_scriptFunctions.append(field[0]);
         }
         position = codeLines.indexOf(rx);
     }
 
-//     m_scriptFunctions = functionList;
 }
 
 ControlObjectThread* MidiScriptEngine::getControlObjectThread(QString group, QString name) {
@@ -478,13 +623,8 @@
         return false;
     }
 
-    if (!m_pEngine->canEvaluate(function)) {
-        qCritical() << "MidiScriptEngine: ?Syntax error in function " << function;
-        return false;
-    }
     QScriptValue slot = m_pEngine->evaluate(function);
 
-
     if(!checkException() && slot.isFunction()) {
         if(disconnect) {
 //             qDebug() << "MidiScriptEngine::connectControl disconnected " << group << name << " from " << function;
@@ -560,6 +700,8 @@
         return false;
     }
 
+    qDebug() << "MidiScriptEngine: Loading" << filename;
+
     // Read in the script file
     QFile input(filename);
     if (!input.open(QIODevice::ReadOnly)) {
@@ -574,8 +716,33 @@
     scriptCode.append('\n');
     input.close();
 
-    if (!m_pEngine->canEvaluate(scriptCode)) {
-        qCritical() << "MidiScriptEngine: ?Syntax error in script file:" << filename;
+    // Check syntax
+    QScriptSyntaxCheckResult result = m_pEngine->checkSyntax(scriptCode);
+    QString error="";
+    switch (result.state()) {
+        case (QScriptSyntaxCheckResult::Valid): break;
+        case (QScriptSyntaxCheckResult::Intermediate):
+            error = "Incomplete code";
+            break;
+        case (QScriptSyntaxCheckResult::Error):
+            error = "Syntax error";
+            break;
+    }
+    if (error!="") {
+        error = QString("%1 at line %2, column %3 in file %4: %5")
+                        .arg(error)
+                        .arg(result.errorLineNumber())
+                        .arg(result.errorColumnNumber())
+                        .arg(filename)
+                        .arg(result.errorMessage());
+
+        if (m_midiDebug) qCritical() << "MidiScriptEngine:" << error;
+        else {
+            qDebug() << "MidiScriptEngine:" << error;
+            qWarning() << "There was an error in the MIDI script file" << filename
+                       << "\nThe functionality provided by this script file will be disabled."
+                          "\nCheck the console or mixxx.log file for details.";
+        }
         return false;
     }
 
@@ -587,7 +754,6 @@
         return false;
 
     // Add the code we evaluated to our index
-    qDebug() << "MidiScriptEngine: Loading" << filename;
     generateScriptFunctions(scriptCode);
 
     return true;
@@ -616,3 +782,99 @@
 }
 
 
+/* -------- ------------------------------------------------------
+   Purpose: Creates & starts a timer that runs some script code
+                on timeout
+   Input:   Number of milliseconds, script function to call,
+                whether it should fire just once
+   Output:  The timer's ID, 0 if starting it failed
+   -------- ------------------------------------------------------ */
+int MidiScriptEngine::beginTimer(int interval, QString scriptCode, bool oneShot) {
+    // When this function runs, assert that somebody is holding the script
+    // engine lock.
+    bool lock = m_scriptEngineLock.tryLock();
+    Q_ASSERT(!lock);
+    if(lock) {
+        m_scriptEngineLock.unlock();
+    }
+
+    if (interval<20) {
+        qDebug() << "Timer request for" << interval << "ms is too short. Setting to the minimum of 20ms.";
+        interval=20;
+    }
+    // This makes use of every QObject's internal timer mechanism. Nice, clean, and simple.
+    // See http://doc.trolltech.com/4.6/qobject.html#startTimer for details
+    int timerId = startTimer(interval);
+    QPair<QString, bool> timerTarget;
+    timerTarget.first = scriptCode;
+    timerTarget.second = oneShot;
+    m_timers[timerId]=timerTarget;
+    if (timerId==0) qDebug() << "MIDI Script timer could not be created";
+    else if (m_midiDebug) {
+        if (oneShot) qDebug() << "Starting one-shot timer:" << timerId;
+        else qDebug() << "Starting timer:" << timerId;
+    }
+    return timerId;
+}
+
+/* -------- ------------------------------------------------------
+   Purpose: Stops & removes a timer
+   Input:   ID of timer to stop
+   Output:  -
+   -------- ------------------------------------------------------ */
+void MidiScriptEngine::stopTimer(int timerId) {
+    // When this function runs, assert that somebody is holding the script
+    // engine lock.
+    bool lock = m_scriptEngineLock.tryLock();
+    Q_ASSERT(!lock);
+    if(lock) m_scriptEngineLock.unlock();
+
+    if (!m_timers.contains(timerId)) {
+        qDebug() << "Killing timer" << timerId << ": That timer does not exist!";
+        return;
+    }
+    if (m_midiDebug) qDebug() << "Killing timer:" << timerId;
+
+    killTimer(timerId);
+    m_timers.remove(timerId);
+}
+
+/* -------- ------------------------------------------------------
+   Purpose: Stops & removes all timers (for shutdown)
+   Input:   -
+   Output:  -
+   -------- ------------------------------------------------------ */
+void MidiScriptEngine::stopAllTimers() {
+    // When this function runs, assert that somebody is holding the script
+    // engine lock.
+    bool lock = m_scriptEngineLock.tryLock();
+    Q_ASSERT(!lock);
+    if(lock) m_scriptEngineLock.unlock();
+
+    QMutableHashIterator<int, QPair<QString, bool> > i(m_timers);
+    while (i.hasNext()) {
+        i.next();
+        stopTimer(i.key());
+    }
+}
+
+/* -------- ------------------------------------------------------
+   Purpose: Runs the appropriate script code on timer events
+   Input:   -
+   Output:  -
+   -------- ------------------------------------------------------ */
+void MidiScriptEngine::timerEvent(QTimerEvent *event) {
+    int timerId = event->timerId();
+
+    m_scriptEngineLock.lock();
+    if (!m_timers.contains(timerId)) {
+        qDebug() << "Timer" << timerId << "fired but there's no function mapped to it!";
+        return;
+    }
+
+    QPair<QString, bool> timerTarget = m_timers[timerId];
+    if (timerTarget.second) stopTimer(timerId);
+
+    internalExecute(timerTarget.first);
+    m_scriptEngineLock.unlock();
+}

=== modified file 'mixxx/src/midi/midiscriptengine.h'
--- mixxx/src/midi/midiscriptengine.h	2009-10-27 07:31:35 +0000
+++ mixxx/src/midi/midiscriptengine.h	2010-03-24 04:40:48 +0000
@@ -38,16 +38,6 @@
     bool hasErrors(QString filename);
     const QStringList getErrors(QString filename);
 
-    // Evaluate a script file
-    bool evaluate(QString filepath);
-    // Execute a particular function
-    bool execute(QString function); 
-    // Execute a particular function with a data string (e.g. a device ID)
-    bool execute(QString function, QString data); 
-    // Execute a particular function with all the data
-    bool execute(QString function, char channel,
-                 char control, char value, MidiStatusByte status, QString group); 
-
     // Lookup registered script functions
     QStringList getScriptFunctions();
 
@@ -58,19 +48,35 @@
     Q_INVOKABLE bool connectControl(QString group, QString name,
                                     QString function, bool disconnect = false);
     Q_INVOKABLE void trigger(QString group, QString name);
+    Q_INVOKABLE int beginTimer(int interval, QString scriptCode, bool oneShot = false);
+    Q_INVOKABLE void stopTimer(int timerId);
 
 public slots:
     void slotValueChanged(double value);
+    // Evaluate a script file
+    bool evaluate(QString filepath);
+    // Execute a particular function
+    bool execute(QString function); 
+    // Execute a particular function with a data string (e.g. a device ID)
+    bool execute(QString function, QString data); 
+    // Execute a particular function with all the data
+    bool execute(QString function, char channel,
+                 char control, char value, MidiStatusByte status, QString group);
+    void loadScriptFiles(QList<QString> scriptFileNames);
+    void initializeScripts(QList<QString> scriptFunctionPrefixes);
+    void gracefulShutdown(QList<QString> scriptFunctionPrefixes);
     
 signals:
     void initialized();
 
 protected:
     void run();
+    void timerEvent(QTimerEvent *event);
 
 private:
     // Only call these with the scriptEngineLock
     bool safeEvaluate(QString filepath);
+    bool internalExecute(QString scriptCode);
     bool safeExecute(QString function);
     bool safeExecute(QString function, QString data);
     bool safeExecute(QString function, char channel, 
@@ -79,18 +85,20 @@
 
     void generateScriptFunctions(QString code);
     bool checkException();
+    void stopAllTimers();
 
     ControlObjectThread* getControlObjectThread(QString group, QString name);
     
     
     MidiDevice* m_pMidiDevice;
+    bool m_midiDebug;
     QHash<ConfigKey, QString> m_connectedControls;
     QScriptEngine *m_pEngine;
     QStringList m_scriptFunctions;
     QMap<QString,QStringList> m_scriptErrors;
     QMutex m_scriptEngineLock;
     QHash<ConfigKey, ControlObjectThread*> m_controlCache;
+	QHash<int, QPair<QString, bool> > m_timers;
 };
 
 #endif
-

=== modified file 'mixxx/src/mixxx.cpp'
--- mixxx/src/mixxx.cpp	2010-02-23 12:10:51 +0000
+++ mixxx/src/mixxx.cpp	2010-03-24 04:40:48 +0000
@@ -476,11 +476,6 @@
 
     qDebug() << "delete config, " << qTime.elapsed();
     delete config;
-
-// Why is this here? The (MSVC 2008) linker even complains about it.
-//#ifdef __WINDOWS__
-//    _exit(0);
-//#endif
 }
 
 int MixxxApp::noSoundDlg(void)