KwidgetProcessorGraph.cpp

Go to the documentation of this file.

namespace krotos
{
    KwidgetProcessorGraph::KwidgetProcessorGraph(int numVoices, int inputChannels, int outputChannels)
        : m_numVoices(numVoices), m_numInputChannels(inputChannels), m_numOutputChannels(outputChannels)
    {
        // Every voice has an AudioProcessorGraph created for it here
        for (int i = 0; i < m_numVoices; i++)
        {
            // Create the AudioProcessorGraph
            auto& graph = *m_graphs.add(new AudioProcessorGraph());
 
            // ... and add one of each type of in/out node to every AudioProcessorGraph
            // and keep pointers to those nodes in m_audioInputNodes, m_audioOutputNodes etc...
            m_audioInputNodes.add(graph.addNode(std::make_unique<IOProcessor>(IOProcessor::audioInputNode)));
            m_audioOutputNodes.add(graph.addNode(std::make_unique<IOProcessor>(IOProcessor::audioOutputNode)));
            m_midiInputNodes.add(graph.addNode(std::make_unique<IOProcessor>(IOProcessor::midiInputNode)));
            m_midiOutputNodes.add(graph.addNode(std::make_unique<IOProcessor>(IOProcessor::midiOutputNode)));
 
            graph.setPlayConfigDetails(m_numInputChannels, m_numOutputChannels, 44100.0, 1024);
            graph.prepareToPlay(44100.0, 1024);
        }
    }
 
    void KwidgetProcessorGraph::addKwidget(std::unique_ptr<Kwidget> kwidgetToAdd)
    {
        auto kwidget = kwidgetToAdd.release();
        auto node = m_graphs[0]->addNode(kwidget->createVoice());
 
        // If you are here, then AudioProcessorGraph did not like the processor you gave it.
        jassert(node != nullptr);
 
        auto id = node->nodeID;
        for (int i = 1; i < getNumVoices(); i++)
            node = m_graphs[i]->addNode(kwidget->createVoice(), id);
 
        m_nodeIDs[kwidget] = node->nodeID;
        m_kwidgets.add(kwidget);
    }
 
    void KwidgetProcessorGraph::removeKwidget(Kwidget* kwidget)
    {
        auto id = getNodeID(kwidget);
        for (auto g : m_graphs)
            g->removeNode(id);
 
        m_kwidgets.removeObject(kwidget);
        m_nodeIDs.erase(kwidget);
    }
 
    bool KwidgetProcessorGraph::canConnect(Kwidget* src, Kwidget* dest)
    {
        return canConnect(getNodeID(src), getNodeID(dest));
    }
 
    void KwidgetProcessorGraph::addConnection(Kwidget* src, Kwidget* dest, int baseChannel, int numConnections)
    {
        addMultipleConnections(getNodeID(src), getNodeID(dest), baseChannel, numConnections);
    }
 
    void KwidgetProcessorGraph::removeConnection(Kwidget* src, Kwidget* dest)
    {
        removeConnection(getNodeID(src), getNodeID(dest));
    }
 
    void KwidgetProcessorGraph::connectToInputNode(Kwidget* dest, int baseChannel, int numConnections)
    {
        addMultipleConnections(m_audioInputNodes[0]->nodeID, getNodeID(dest), baseChannel, numConnections);
    }
 
    void KwidgetProcessorGraph::connectToOutputNode(Kwidget* src, int baseChannel, int numChannels)
    {
        addMultipleConnectionsToOutputNode(getNodeID(src), baseChannel, numChannels);
    }
 
    void KwidgetProcessorGraph::clearConnections()
    {
        auto connections = m_graphs[0]->getConnections();
 
        for (auto& c : connections)
            for (auto g : m_graphs)
                g->removeConnection(c);
    }
 
    void KwidgetProcessorGraph::clearKwidgets()
    {
        std::vector<Kwidget*> currentKwidgets;
 
        for (auto& kwidget : m_kwidgets)
            currentKwidgets.push_back(kwidget);
 
        for (auto& kwidget : currentKwidgets)
            removeKwidget(kwidget);
    }
 
    void KwidgetProcessorGraph::prepareToPlay(double sampleRate, int samplesPerBlock)
    {
        m_sampleRate = sampleRate;
        m_blockSize = samplesPerBlock;
 
        for (int i = 0; i < getNumVoices(); i++)
        {
            auto& g = *m_graphs[i];
            g.setPlayConfigDetails(m_numInputChannels, m_numOutputChannels, sampleRate, samplesPerBlock);
            g.prepareToPlay(sampleRate, samplesPerBlock);
        }
    }
 
    void KwidgetProcessorGraph::noteOn(int voiceIdx, int midiNote, float velocity)
    {
        jassert(isPositiveAndBelow(voiceIdx, getNumVoices()));
 
        for (auto k : m_kwidgets)
        {
            if (!k->isAChildKwidget()) // We ignore child kwidgets
            {
                k->noteOn(voiceIdx, midiNote, velocity);
            }
        }
    }
 
    void KwidgetProcessorGraph::noteOff(int voiceIdx, float velocity)
    {
        jassert(isPositiveAndBelow(voiceIdx, getNumVoices()));
 
        for (auto k : m_kwidgets)
        {
            if (!k->isAChildKwidget()) // We ignore child kwidgets
            {
                k->noteOff(voiceIdx, velocity);
            }
        }
    }
 
    void KwidgetProcessorGraph::noteCleared(int voiceIdx)
    {
        jassert(isPositiveAndBelow(voiceIdx, getNumVoices()));
 
        // Clears every processor including child kwidget processors
        for (auto k : m_kwidgets)
        {
            k->noteCleared(voiceIdx);
        }
    }
 
    bool KwidgetProcessorGraph::isActive(int voiceIdx)
    {
        jassert(isPositiveAndBelow(voiceIdx, getNumVoices()));
 
        for (auto k : m_kwidgets)
        {
            if (!k->isAChildKwidget()) // We don't poll child kwidgets - parents must do that
            {
                if (k->isActive(voiceIdx))
                {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    void KwidgetProcessorGraph::processVoice(int voiceIdx, AudioBuffer<float>& buffer)
    {
        jassert(isPositiveAndBelow(voiceIdx, getNumVoices()));
 
        MidiBuffer m;
        m_graphs[voiceIdx]->processBlock(buffer, m);
    }
 
    void KwidgetProcessorGraph::debugConnections() const
    {
        auto connections = m_graphs[0]->getConnections();
 
        for (auto& c : connections)
        {
            auto src = m_graphs[0]->getNodeForId(c.source.nodeID)->getProcessor();
            auto dest = m_graphs[0]->getNodeForId(c.destination.nodeID)->getProcessor();
 
            String srcID = "";
            if (auto kp = dynamic_cast<KwidgetProcessor*>(src))
                srcID = kp->getKwidgetID();
 
            String destID = "";
            if (auto kp = dynamic_cast<KwidgetProcessor*>(dest))
                destID = kp->getKwidgetID();
 
            DBG("Connection\nChannel: " << c.source.channelIndex << "\nSource: " << srcID
                                        << "\nDest: " << destID + "\n");
        }
    }
 
    AudioProcessorGraph::NodeID KwidgetProcessorGraph::getNodeID(Kwidget* k)
    {
        jassert(m_nodeIDs.count(k) == 1);
        return m_nodeIDs.at(k);
    }
 
    bool KwidgetProcessorGraph::canConnect(NodeID src, NodeID dest)
    {
        auto g = m_graphs.getUnchecked(0);
 
        if (g->isAnInputTo(*g->getNodeForId(dest), *g->getNodeForId(src)))
            return false;
 
        // TODO During the big refactor, replace this commented out code with something which doesn't always return true
        // if (g->isConnected(src, dest))
        //    return false;
        /*
                for (int i = 0; i < m_numOutputChannels; i++)
                    if (g->canConnect({ { src, i }, { dest, i } }) == false)
                        return false;
        */
        return true;
    }
 
    void KwidgetProcessorGraph::addMultipleConnections(NodeID src, NodeID dest, int baseChannel, int numConnections)
    {
        jassert(baseChannel <= m_numOutputChannels - numConnections);
        for (auto g : m_graphs)
            for (int channel = 0; channel < numConnections; channel++)
                if (g->addConnection({{src, channel}, {dest, channel + baseChannel}}) == false)
                    jassertfalse;
    }
 
    void KwidgetProcessorGraph::addMultipleConnectionsToOutputNode(NodeID src, int baseChannel, int numConnections)
    {
        jassert(baseChannel <= m_numOutputChannels - numConnections);
 
        for (int graphIndex = 0; graphIndex < m_graphs.size(); graphIndex++)
        {
            auto g = m_graphs[graphIndex];
            auto outputNodeID = m_audioOutputNodes[graphIndex]->nodeID;
            for (int channel = 0; channel < numConnections; channel++)
            {
                if (g->addConnection({{src, channel}, {outputNodeID, channel + baseChannel}}) == false)
                {
                    jassertfalse;
                }
            }
        }
    }
 
    void KwidgetProcessorGraph::removeConnection(NodeID src, NodeID dest)
    {
        for (auto g : m_graphs)
            for (int i = 0; i < m_numOutputChannels; i++)
                g->removeConnection({{src, i}, {dest, i}});
    }
} // namespace krotos