Add an effects framework.

build/depends.py

@@ -560,6 +560,35 @@ def sources(self, build):
                    "dlghidden.cpp",
                    "dlgmissing.cpp",
 
+                   "effects/effectmanifest.cpp",
+                   "effects/effectmanifestparameter.cpp",
+
+                   "effects/effectchain.cpp",
+                   "effects/effect.cpp",
+                   "effects/effectparameter.cpp",
+
+                   "effects/effectrack.cpp",
+                   "effects/effectchainslot.cpp",
+                   "effects/effectslot.cpp",
+                   "effects/effectparameterslot.cpp",
+
+                   "effects/effectsmanager.cpp",
+                   "effects/effectchainmanager.cpp",
+                   "effects/effectsbackend.cpp",
+
+                   "effects/native/nativebackend.cpp",
+                   "effects/native/bitcrushereffect.cpp",
+                   "effects/native/flangereffect.cpp",
+                   "effects/native/filtereffect.cpp",
+                   "effects/native/reverbeffect.cpp",
+                   "effects/native/echoeffect.cpp",
+                   "effects/native/reverb/Reverb.cc",
+
+                   "engine/effects/engineeffectsmanager.cpp",
+                   "engine/effects/engineeffectrack.cpp",
+                   "engine/effects/engineeffectchain.cpp",
+                   "engine/effects/engineeffect.cpp",
+
                    "engine/sync/basesyncablelistener.cpp",
                    "engine/sync/enginesync.cpp",
                    "engine/sync/synccontrol.cpp",
@@ -580,8 +609,6 @@ def sources(self, build):
                    "engine/enginechannel.cpp",
                    "engine/enginemaster.cpp",
                    "engine/enginedelay.cpp",
-                   "engine/engineflanger.cpp",
-                   "engine/enginefiltereffect.cpp",
                    "engine/enginevumeter.cpp",
                    "engine/enginevinylsoundemu.cpp",
                    "engine/enginesidechaincompressor.cpp",
@@ -664,6 +691,9 @@ def sources(self, build):
                    "widget/wimagestore.cpp",
                    "widget/hexspinbox.cpp",
                    "widget/wtrackproperty.cpp",
+                   "widget/weffectchain.cpp",
+                   "widget/weffect.cpp",
+                   "widget/weffectparameter.cpp",
                    "widget/wtime.cpp",
                    "widget/wkey.cpp",
                    "widget/wcombobox.cpp",

src/basetrackplayer.cpp

@@ -15,25 +15,26 @@
 #include "waveform/renderers/waveformwidgetrenderer.h"
 #include "analyserqueue.h"
 #include "util/sandbox.h"
+#include "effects/effectsmanager.h"
 
 BaseTrackPlayer::BaseTrackPlayer(QObject* pParent,
                                  ConfigObject<ConfigValue>* pConfig,
                                  EngineMaster* pMixingEngine,
+                                 EffectsManager* pEffectsManager,
                                  EngineChannel::ChannelOrientation defaultOrientation,
                                  QString group,
                                  bool defaultMaster,
                                  bool defaultHeadphones)
         : BasePlayer(pParent, group),
           m_pConfig(pConfig),
           m_pLoadedTrack() {
-
     // Need to strdup the string because EngineChannel will save the pointer,
     // but we might get deleted before the EngineChannel. TODO(XXX)
     // pSafeGroupName is leaked. It's like 5 bytes so whatever.
     const char* pSafeGroupName = strdup(getGroup().toAscii().constData());
 
-    m_pChannel = new EngineDeck(pSafeGroupName,
-                                pConfig, pMixingEngine, defaultOrientation);
+    m_pChannel = new EngineDeck(pSafeGroupName, pConfig, pMixingEngine,
+                                pEffectsManager, defaultOrientation);
 
     EngineBuffer* pEngineBuffer = m_pChannel->getEngineBuffer();
     pMixingEngine->addChannel(m_pChannel);

src/basetrackplayer.h

@@ -12,13 +12,15 @@ class ControlObject;
 class ControlPotmeter;
 class ControlObjectThread;
 class AnalyserQueue;
+class EffectsManager;
 
 class BaseTrackPlayer : public BasePlayer {
     Q_OBJECT
   public:
     BaseTrackPlayer(QObject* pParent,
                     ConfigObject<ConfigValue>* pConfig,
                     EngineMaster* pMixingEngine,
+                    EffectsManager* pEffectsManager,
                     EngineChannel::ChannelOrientation defaultOrientation,
                     QString group,
                     bool defaultMaster,

src/controlvaluedelegate.h

@@ -41,6 +41,7 @@ class ControlValueDelegate : public QItemDelegate
     static QStringList getPlaylistControlValues() { return m_playlistControlValues; };
     static QStringList getFlangerControlValues() { return m_flangerControlValues; };
     static QStringList getMicrophoneControlValues() { return m_microphoneControlValues; };
+
 private:
     static QStringList m_channelControlValues;
     static QStringList m_masterControlValues;

src/deck.cpp

@@ -3,12 +3,12 @@
 Deck::Deck(QObject* pParent,
            ConfigObject<ConfigValue>* pConfig,
            EngineMaster* pMixingEngine,
+           EffectsManager* pEffectsManager,
            EngineChannel::ChannelOrientation defaultOrientation,
            QString group) :
-        BaseTrackPlayer(pParent, pConfig, pMixingEngine, defaultOrientation,
-                          group, true, false) {
+        BaseTrackPlayer(pParent, pConfig, pMixingEngine, pEffectsManager,
+                        defaultOrientation, group, true, false) {
 }
 
 Deck::~Deck() {
 }
-

src/deck.h

@@ -11,6 +11,7 @@ class Deck : public BaseTrackPlayer {
     Deck(QObject* pParent,
          ConfigObject<ConfigValue>* pConfig,
          EngineMaster* pMixingEngine,
+         EffectsManager* pEffectsManager,
          EngineChannel::ChannelOrientation defaultOrientation,
          QString group);
     virtual ~Deck();

src/defs.h

@@ -71,5 +71,8 @@ enum {
 #define math_min(a,b)            (((a) < (b)) ? (a) : (b))
 #endif
 
+#ifndef math_clamp
+#define math_clamp(v, min, max)  (((min) < (max)) ? (math_min((max), math_max((v), (min)))) : (math_min((min), math_max((v), (max)))))
 #endif
 
+#endif

src/effects/effect.cpp

@@ -0,0 +1,165 @@
+#include <QtDebug>
+
+#include "effects/effect.h"
+#include "effects/effectprocessor.h"
+#include "effects/effectsmanager.h"
+#include "engine/effects/engineeffectchain.h"
+#include "engine/effects/engineeffect.h"
+#include "xmlparse.h"
+
+Effect::Effect(QObject* pParent, EffectsManager* pEffectsManager,
+               const EffectManifest& manifest,
+               EffectInstantiatorPointer pInstantiator)
+        : QObject(pParent),
+          m_pEffectsManager(pEffectsManager),
+          m_manifest(manifest),
+          m_pEngineEffect(new EngineEffect(manifest,
+                                           pEffectsManager->registeredGroups(),
+                                           pInstantiator)),
+          m_bAddedToEngine(false),
+          m_bEnabled(true) {
+    foreach (const EffectManifestParameter& parameter, m_manifest.parameters()) {
+        EffectParameter* pParameter = new EffectParameter(
+            this, pEffectsManager, m_parameters.size(), parameter);
+        m_parameters.append(pParameter);
+        if (m_parametersById.contains(parameter.id())) {
+            qDebug() << debugString() << "WARNING: Loaded EffectManifest that had parameters with duplicate IDs. Dropping one of them.";
+        }
+        m_parametersById[parameter.id()] = pParameter;
+    }
+}
+
+Effect::~Effect() {
+    qDebug() << debugString() << "destroyed";
+    m_parametersById.clear();
+    for (int i = 0; i < m_parameters.size(); ++i) {
+        EffectParameter* pParameter = m_parameters.at(i);
+        m_parameters[i] = NULL;
+        delete pParameter;
+    }
+}
+
+void Effect::addToEngine(EngineEffectChain* pChain, int iIndex) {
+    EffectsRequest* request = new EffectsRequest();
+    request->type = EffectsRequest::ADD_EFFECT_TO_CHAIN;
+    request->pTargetChain = pChain;
+    request->AddEffectToChain.pEffect = m_pEngineEffect;
+    request->AddEffectToChain.iIndex = iIndex;
+    m_pEffectsManager->writeRequest(request);
+    m_bAddedToEngine = true;
+    foreach (EffectParameter* pParameter, m_parameters) {
+        pParameter->addToEngine();
+    }
+}
+
+void Effect::removeFromEngine(EngineEffectChain* pChain, int iIndex) {
+    EffectsRequest* request = new EffectsRequest();
+    request->type = EffectsRequest::REMOVE_EFFECT_FROM_CHAIN;
+    request->pTargetChain = pChain;
+    request->RemoveEffectFromChain.pEffect = m_pEngineEffect;
+    request->RemoveEffectFromChain.iIndex = iIndex;
+    m_pEffectsManager->writeRequest(request);
+    m_bAddedToEngine = false;
+    foreach (EffectParameter* pParameter, m_parameters) {
+        pParameter->removeFromEngine();
+    }
+}
+
+void Effect::updateEngineState() {
+    if (!m_bAddedToEngine) {
+        return;
+    }
+    sendParameterUpdate();
+    foreach (EffectParameter* pParameter, m_parameters) {
+        pParameter->updateEngineState();
+    }
+}
+
+EngineEffect* Effect::getEngineEffect() {
+    return m_pEngineEffect;
+}
+
+const EffectManifest& Effect::getManifest() const {
+    return m_manifest;
+}
+
+void Effect::setEnabled(bool enabled) {
+    if (enabled != m_bEnabled) {
+        m_bEnabled = enabled;
+        updateEngineState();
+        emit(enabledChanged(m_bEnabled));
+    }
+}
+
+bool Effect::enabled() const {
+    return m_bEnabled;
+}
+
+void Effect::sendParameterUpdate() {
+    if (!m_bAddedToEngine) {
+        return;
+    }
+    EffectsRequest* pRequest = new EffectsRequest();
+    pRequest->type = EffectsRequest::SET_EFFECT_PARAMETERS;
+    pRequest->pTargetEffect = m_pEngineEffect;
+    pRequest->SetEffectParameters.enabled = m_bEnabled;
+    m_pEffectsManager->writeRequest(pRequest);
+}
+
+unsigned int Effect::numParameters() const {
+    return m_parameters.size();
+}
+
+void Effect::onChainParameterChanged(double chainParameter) {
+    foreach (EffectParameter* pParameter, m_parameters) {
+        pParameter->onChainParameterChanged(chainParameter);
+    }
+}
+
+EffectParameter* Effect::getParameterById(const QString& id) const {
+    EffectParameter* pParameter = m_parametersById.value(id, NULL);
+    if (pParameter == NULL) {
+        qDebug() << debugString() << "getParameterById"
+                 << "WARNING: parameter for id does not exist:" << id;
+    }
+    return pParameter;
+}
+
+EffectParameter* Effect::getParameter(unsigned int parameterNumber) {
+    EffectParameter* pParameter = m_parameters.value(parameterNumber, NULL);
+    if (pParameter == NULL) {
+        qDebug() << debugString() << "WARNING: Invalid parameter index.";
+    }
+    return pParameter;
+}
+
+QDomElement Effect::toXML(QDomDocument* doc) const {
+    QDomElement element = doc->createElement("Effect");
+    XmlParse::addElement(*doc, element, "Id", m_manifest.id());
+    XmlParse::addElement(*doc, element, "Version", m_manifest.version());
+
+    QDomElement parameters = doc->createElement("Parameters");
+    foreach (EffectParameter* pParameter, m_parameters) {
+        const EffectManifestParameter& parameterManifest =
+                pParameter->manifest();
+        QDomElement parameter = doc->createElement("Parameter");
+        XmlParse::addElement(*doc, parameter, "Id", parameterManifest.id());
+        // TODO(rryan): Do smarter QVariant formatting?
+        XmlParse::addElement(*doc, parameter, "Value",
+                             pParameter->getValue().toString());
+        // TODO(rryan): Output link state, etc.
+        parameters.appendChild(parameter);
+    }
+    element.appendChild(parameters);
+
+    return element;
+}
+
+// static
+EffectPointer Effect::fromXML(EffectsManager* pEffectsManager,
+                              const QDomElement& element) {
+    QString effectId = XmlParse::selectNodeQString(element, "Id");
+    EffectPointer pEffect = pEffectsManager->instantiateEffect(effectId);
+    // TODO(rryan): Load parameter values / etc. from element.
+    return pEffect;
+}

src/effects/effect.h

@@ -0,0 +1,75 @@
+#ifndef EFFECT_H
+#define EFFECT_H
+
+#include <QSharedPointer>
+#include <QDomDocument>
+
+#include "defs.h"
+#include "util.h"
+#include "effects/effectmanifest.h"
+#include "effects/effectparameter.h"
+#include "effects/effectinstantiator.h"
+
+class EffectProcessor;
+class EngineEffectChain;
+class EngineEffect;
+class EffectsManager;
+
+class Effect;
+typedef QSharedPointer<Effect> EffectPointer;
+
+// The Effect class is the main-thread representation of an instantiation of an
+// effect. This class is NOT thread safe and must only be used by the main
+// thread. The getEngineEffect() method can be used to get a pointer to the
+// Engine-thread representation of the effect.
+class Effect : public QObject {
+    Q_OBJECT
+  public:
+    Effect(QObject* pParent, EffectsManager* pEffectsManager,
+           const EffectManifest& manifest,
+           EffectInstantiatorPointer pInstantiator);
+    virtual ~Effect();
+
+    const EffectManifest& getManifest() const;
+
+    unsigned int numParameters() const;
+    EffectParameter* getParameter(unsigned int parameterNumber);
+    EffectParameter* getParameterById(const QString& id) const;
+
+    void setEnabled(bool enabled);
+    bool enabled() const;
+
+    EngineEffect* getEngineEffect();
+
+    void onChainParameterChanged(double chainParameter);
+
+    void addToEngine(EngineEffectChain* pChain, int iIndex);
+    void removeFromEngine(EngineEffectChain* pChain, int iIndex);
+    void updateEngineState();
+
+    QDomElement toXML(QDomDocument* doc) const;
+    static EffectPointer fromXML(EffectsManager* pEffectsManager,
+                                 const QDomElement& element);
+
+  signals:
+    void enabledChanged(bool enabled);
+
+  private:
+    QString debugString() const {
+        return QString("Effect(%1)").arg(m_manifest.name());
+    }
+
+    void sendParameterUpdate();
+
+    EffectsManager* m_pEffectsManager;
+    EffectManifest m_manifest;
+    EngineEffect* m_pEngineEffect;
+    bool m_bAddedToEngine;
+    bool m_bEnabled;
+    QList<EffectParameter*> m_parameters;
+    QMap<QString, EffectParameter*> m_parametersById;
+
+    DISALLOW_COPY_AND_ASSIGN(Effect);
+};
+
+#endif /* EFFECT_H */