Merge lp:~zestoi/mixxx/spinback_brake into lp:~mixxxdevelopers/mixxx/trunk

[Zestoi]

implements a spinback/brake effect in the engine

new function: ControllerEngine::brake() to enable/disable the effect

modified function: ControllerEngine::scratchProcess()

* m_rampFactor[deck] variable instead of 0.0001 constant
* extra logic to work out when the scratch timer can be disabled
* m_brakeActive[deck] to store whether we are in this effect or normal scratching mode
* m_brakeKeylock[deck] to store the keylock status so we can disable for the effect and re-enable afterwards if we need to

[RJ Skerry-Ryan (rryan)]

LGTM -- thanks zestoi!

review: Approve

=== modified file 'mixxx/src/controllers/controllerengine.cpp'
--- mixxx/src/controllers/controllerengine.cpp	2012-05-01 21:42:24 +0000
+++ mixxx/src/controllers/controllerengine.cpp	2012-05-26 16:40:25 +0000
@@ -41,6 +41,9 @@
     m_rampTo.resize(kDecks);
     m_ramp.resize(kDecks);
     m_pitchFilter.resize(kDecks);
+    m_rampFactor.resize(kDecks);
+    m_brakeActive.resize(kDecks);
+    m_brakeKeylock.resize(kDecks);
 
     // Initialize arrays used for testing and pointers
     for (int i=0; i < kDecks; i++) {
@@ -945,6 +948,8 @@
     m_dx[deck] = 1/intervalsPerSecond;
     m_intervalAccumulator[deck] = 0;
     m_ramp[deck] = false;
+    m_rampFactor[deck] = 0.001;
+    m_brakeActive[deck] = false;
 
     QString group = QString("[Channel%1]").arg(deck);
 
@@ -1030,8 +1035,9 @@
     -------- ------------------------------------------------------ */
 void ControllerEngine::scratchProcess(int timerId) {
     int deck = m_scratchTimers[timerId];
+    QString group = QString("[Channel%1]").arg(deck);
     PitchFilter* filter = m_pitchFilter[deck];
-    QString group = QString("[Channel%1]").arg(deck);
+    float pitch = filter->currentPitch();
 
     if (!filter) {
         qWarning() << "Scratch filter pointer is null on deck" << deck;
@@ -1042,7 +1048,7 @@
 
     // If we're ramping to end scratching, feed fixed data
     if (m_ramp[deck]) {
-        filter->observation(m_rampTo[deck]*0.001);
+        filter->observation(m_rampTo[deck]*m_rampFactor[deck]);
     } else {
         //  This will (and should) be 0 if no net ticks have been accumulated
         //  (i.e. the wheel is stopped)
@@ -1059,17 +1065,26 @@
     m_intervalAccumulator[deck] = 0;
 
     // If we're ramping and the current pitch is really close to the rampTo
-    // value, end scratching
+    // value or we're in brake mode and have crossed over the zero value, end scratching
 
     //if (m_ramp[deck]) qDebug() << "Ramping to" << m_rampTo[deck] << " Currently at:" << filter->currentPitch();
-    if (m_ramp[deck] && fabs(m_rampTo[deck]-filter->currentPitch()) <= 0.00001) {
+    if ((m_ramp[deck] && fabs(m_rampTo[deck]-filter->currentPitch()) <= 0.00001)
+        || (m_brakeActive[deck] && ((pitch > 0.0 &&  filter->currentPitch() < 0.0) || (pitch < 0.0 &&  filter->currentPitch() > 0.0)))) {
+
         // Not ramping no mo'
         m_ramp[deck] = false;
 
-        // Clear scratch2_enable
-        cot = getControlObjectThread(group, "scratch2_enable");
-        if(cot != NULL) {
-            cot->slotSet(0);
+        // Clear scratch2_enable unless brake mode where we just set scratch2 to 0.0
+        if (m_brakeActive[deck]) {
+            if (cot != NULL) {
+                cot->slotSet(0.0);
+            }
+        }
+        else {
+            cot = getControlObjectThread(group, "scratch2_enable");
+            if(cot != NULL) {
+                cot->slotSet(0);
+            }
         }
 
         // Remove timer
@@ -1077,6 +1092,7 @@
         m_scratchTimers.remove(timerId);
 
         m_dx[deck] = 0.0;
+        m_brakeActive[deck] = false;
     }
 }
 
@@ -1154,3 +1170,78 @@
         m_st.disable(pControl);
     }
 }
+
+/*  -------- ------------------------------------------------------
+    Purpose: [En/dis]ables spinback effect for the channel
+    Input:   deck, activate/deactivate, factor (optional), 
+             delay (optional), rate (optional)
+    Output:  -
+    -------- ------------------------------------------------------ */
+void ControllerEngine::spinback(int deck, bool activate, float factor, float rate) {
+    // defaults for args set in header file
+    brake(deck, activate, factor, rate);
+}
+
+/*  -------- ------------------------------------------------------
+    Purpose: [En/dis]ables brake/spinback effect for the channel
+    Input:   deck, activate/deactivate, factor (optional), 
+             delay (optional), rate (optional)
+    Output:  -
+    -------- ------------------------------------------------------ */
+void ControllerEngine::brake(int deck, bool activate, float factor, float rate) {
+    QString group = QString("[Channel%1]").arg(deck);
+
+    // kill timer when both enabling or disabling
+    int timerId = m_scratchTimers.key(deck);
+    killTimer(timerId);
+    m_scratchTimers.remove(timerId);
+
+    // enable/disable scratch2 mode
+    ControlObjectThread *cot = getControlObjectThread(group, "scratch2_enable");
+    if (cot != NULL) {
+        cot->slotSet(activate ? 1 : 0);
+    }
+
+    // used in scratchProcess for the different timer behaviour we need
+    m_brakeActive[deck] = activate;
+
+    if (activate) {
+        // store the new values for this spinback/brake effect
+        m_rampFactor[deck] = rate * factor / 100000; // approx 1 second for a factor of 1
+        m_rampTo[deck] = -1.0;
+
+        // save current keylock status and disable
+        cot = getControlObjectThread(group, "keylock");
+        if (cot != NULL) {
+            m_brakeKeylock[deck] = cot->get();
+            cot->slotSet(0);
+        }
+
+        // setup timer and send first scratch2 'tick' 
+        int timerId = startTimer(1);
+        m_scratchTimers[timerId] = deck;
+
+        cot = getControlObjectThread(group, "scratch2");
+        if (cot != NULL) {
+            cot->slotSet(rate);
+        }
+
+        // setup the filter
+        PitchFilter* filter = m_pitchFilter[deck];
+        if (filter != NULL) {
+            m_pitchFilter[deck]->init(0.001, rate);
+        }
+
+        // activate the ramping in scratchProcess()
+        m_ramp[deck] = true;    
+    }
+    else {
+        // re-enable keylock if needed
+        if (m_brakeKeylock[deck]) {
+            cot = getControlObjectThread(group, "keylock");
+            if (cot != NULL) {
+                cot->slotSet(1);
+            }
+        }
+    }
+}

=== modified file 'mixxx/src/controllers/controllerengine.h'
--- mixxx/src/controllers/controllerengine.h	2012-04-27 04:04:33 +0000
+++ mixxx/src/controllers/controllerengine.h	2012-05-26 16:40:25 +0000
@@ -59,6 +59,8 @@
     Q_INVOKABLE void scratchTick(int deck, int interval);
     Q_INVOKABLE void scratchDisable(int deck, bool ramp = true);
     Q_INVOKABLE void softTakeover(QString group, QString name, bool set);
+    Q_INVOKABLE void brake(int deck, bool activate, float factor=0.9, float rate=1.0);
+    Q_INVOKABLE void spinback(int deck, bool activate, float factor=1.8, float rate=-10.0);
 
     // Handler for timers that scripts set.
     virtual void timerEvent(QTimerEvent *event);
@@ -117,9 +119,9 @@
     ByteArrayClass *m_pBaClass;
     // 256 (default) available virtual decks is enough I would think.
     //  If more are needed at run-time, these will move to the heap automatically
-    QVarLengthArray<int> m_intervalAccumulator;
-    QVarLengthArray<float> m_dx, m_rampTo;
-    QVarLengthArray<bool> m_ramp;
+    QVarLengthArray<int> m_intervalAccumulator, m_brakeKeylock;
+    QVarLengthArray<float> m_dx, m_rampTo, m_rampFactor;
+    QVarLengthArray<bool> m_ramp, m_brakeActive;
     QVarLengthArray<PitchFilter*> m_pitchFilter;
     QHash<int, int> m_scratchTimers;
 };