KwidgetSynthesiser.cpp

Go to the documentation of this file.

namespace krotos
{
    bool KwidgetSynthSound::appliesToNote(int /*midiNoteNumber*/) { return true; }
    bool KwidgetSynthSound::appliesToChannel(int /*midiChannel*/) { return true; }
 
    KwidgetSynthVoice::KwidgetSynthVoice(int idx, int numOutputChannels, std::vector<KwidgetProcessorGraph*> processors)
        : m_voiceIndex(idx)
    {
        m_workingBuffer.setSize(numOutputChannels, 4096);
 
        for (auto p : processors)
            addProcessor(p);
    }
 
    bool KwidgetSynthVoice::canPlaySound(SynthesiserSound* s)
    {
        if (dynamic_cast<KwidgetSynthSound*>(s))
            return true;
 
        return false;
    }
 
    // Called from Synthesiser::startVoice
    void KwidgetSynthVoice::startNote(int midiNote, float velocity, SynthesiserSound*, int)
    {
        // m_voiceIndex was set when the voice was created - it is a way of identifying this voice
        for (auto p : m_processors)
            p->noteOn(m_voiceIndex, midiNote, velocity);
    }
 
    void KwidgetSynthVoice::stopNote(float velocity, bool allowTailOff)
    {
        for (auto p : m_processors)
            p->noteOff(m_voiceIndex, velocity);
 
        if (!allowTailOff) // Are we electing not to wait for the ADSR release phase to time out ?
        {
            for (auto p : m_processors) // Then stop everthing playing
                p->noteCleared(m_voiceIndex);
            clearCurrentNote(); // Kill this voice
        }
    }
 
    void KwidgetSynthVoice::pitchWheelMoved(int) {}
 
    void KwidgetSynthVoice::controllerMoved(int, int) {}
 
    void KwidgetSynthVoice::renderNextBlock(AudioBuffer<float>& ioBuffer, int startSample, int numSamples)
    {
        if (!isVoiceActive())
            return;
 
        int workingChannels =
                ioBuffer.getNumChannels(); // This is the number of channels we will actaully process in this block
 
        jassert(m_workingBuffer.getNumChannels() >= workingChannels);
 
        auto tempBufferPtrsArray = m_workingBuffer.getArrayOfWritePointers();
        auto ioBufferPtrsArray = ioBuffer.getArrayOfWritePointers();
 
        // Create a temporary audio buffer with workingChannels channels useing memory pre-allocated in m_workingBuffer
        AudioBuffer<float> tempBuf{tempBufferPtrsArray, workingChannels, startSample, numSamples};
 
        // Call all the processors in the graph
        for (auto p : m_processors)
        {
            p->processVoice(m_voiceIndex, tempBuf);
        }
 
        // Output from the audio graph is now in tempBuffer
        // Sum the output from the temprary buffer back into our input/ouput buffer
        for (int j = 0; j < workingChannels; j++)
            FloatVectorOperations::add(ioBufferPtrsArray[j] + startSample, tempBufferPtrsArray[j] + startSample,
                                       numSamples);
 
        bool active = false;
        for (auto p : m_processors)
        {
            if (p->isActive(m_voiceIndex))
            {
                active = true;
                break;
            }
        }
 
#ifdef USE_VOICE_DEBUG_PRINTOUT
        if (isActive_old && !active)
        {
            DBG("Inactive " + String(m_voiceIndex));
        }
        if (!isActive_old && active)
        {
            DBG("Active " + String(m_voiceIndex));
        }
        isActive_old = active;
#endif
 
        // At the moment the only Kwidget which reports back its active state is the Core Engine kwidget
        // as no other Kwidget in our current configuration contributes to control over the lifetime of the voice.
        // The core engine takes account of its own children, including amplitude ADSR, whos active state it will take
        // account of It does this by overriding the Kwidget class isActive() method and providing its own logic. Other
        // Kwidgets which are not doing that, call the method default and return the value supplied by their associated
        // processor isActive() method. This means that other Kwidgets may still be active when the Core Engine and its
        // ADSR goes inactive, and need to be cleared. In the case of the core engine, eg if it goes inactive due to
        // ADSR timeout, clearing is an important step, as it clears the still playing grain(s) and returns the
        // resources to the grain pool. Note: If an ADSR kwidget is instantiated in the default manner, ie not as a
        // child of another kwidget, it's isActive method will be polled directly and contribute directly to the voice
        // lifetime
 
        if (!active)
        {
            // Clear every processor for the voice we are dealing with
            for (auto p : m_processors)
                p->noteCleared(m_voiceIndex);
 
            clearCurrentNote();
        }
    }
 
    void KwidgetSynthVoice::addProcessor(KwidgetProcessorGraph* p)
    {
        jassert(isPositiveAndBelow(m_voiceIndex, p->getNumVoices()));
        m_processors.add(p);
    }
 
    KwidgetSynth::KwidgetSynth(KwidgetProcessorGraph& mainGraph, KwidgetProcessorGraph& modulatorGraph,
                               int voicesOffset, int forceNumVoices, int numOutputChannels)
    {
        auto numVoices = forceNumVoices;
 
        if (numVoices == 0) // If the caller is not electing to force the number of voices ...
        {
            // ... then they are set from the graphs
            numVoices = mainGraph.getNumVoices();
            jassert(numVoices == modulatorGraph.getNumVoices());
        }
 
        addSound(new KwidgetSynthSound());
 
        // voicesOffset allows the range of voices index to be continuous globally
        for (int i = 0; i < numVoices; i++)
            addVoice(new KwidgetSynthVoice(voicesOffset + i, numOutputChannels, {&modulatorGraph, &mainGraph}));
    }
 
    void KwidgetSynth::processBlock(AudioBuffer<float>& buffer, MidiBuffer& midi)
    {
        renderNextBlock(buffer, midi, 0, buffer.getNumSamples());
    }
 
    int KwidgetSynth::getNumActiveVoices()
    {
        int numActiveVoices = 0;
        for (int i = 0; i < getNumVoices(); i++)
        {
            auto voice = getVoice(i);
            if (voice->isVoiceActive())
                numActiveVoices++;
        }
        return numActiveVoices;
    }
 
    void KwidgetSynth::setSamePitchNoteStealingEnable(bool newState) { m_samePitchNoteStealingEnabled = newState; }
 
    SynthesiserVoice* KwidgetSynth::findVoiceToSteal(SynthesiserSound* soundToPlay, int /*midiChannel*/,
                                                     int midiNoteNumber) const
    {
        // This voice-stealing algorithm applies the following heuristics:
        // - Re-use the oldest notes first
        // - Protect the lowest & topmost notes, even if sustained, but not if they've been released.
 
        // apparently you are trying to render audio without having any voices...
        jassert(!voices.isEmpty());
 
        // These are the voices we want to protect (ie: only steal if unavoidable)
        SynthesiserVoice* low = nullptr; // Lowest sounding note, might be sustained, but NOT in release phase
        SynthesiserVoice* top = nullptr; // Highest sounding note, might be sustained, but NOT in release phase
 
        // this is a list of voices we can steal, sorted by how long they've been running
        Array<SynthesiserVoice*> usableVoices;
        usableVoices.ensureStorageAllocated(voices.size());
 
        for (auto* voice : voices)
        {
            if (voice->canPlaySound(soundToPlay))
            {
                jassert(voice->isVoiceActive()); // We wouldn't be here otherwise
 
                usableVoices.add(voice);
 
                // NB: Using a functor rather than a lambda here due to scare-stories about
                // compilers generating code containing heap allocations..
                struct Sorter
                {
                    bool operator()(const SynthesiserVoice* a, const SynthesiserVoice* b) const noexcept
                    {
                        return a->wasStartedBefore(*b);
                    }
                };
 
                std::sort(usableVoices.begin(), usableVoices.end(), Sorter());
 
                if (!voice->isPlayingButReleased()) // Don't protect released notes
                {
                    auto note = voice->getCurrentlyPlayingNote();
 
                    if (low == nullptr || note < low->getCurrentlyPlayingNote())
                        low = voice;
 
                    if (top == nullptr || note > top->getCurrentlyPlayingNote())
                        top = voice;
                }
            }
        }
 
        // Eliminate pathological cases (ie: only 1 note playing): we always give precedence to the lowest note(s)
        if (top == low)
            top = nullptr;
 
        // The oldest note that's playing with the target pitch is ideal..
        if (m_samePitchNoteStealingEnabled) // Overriding findVoiceToSteal() and adding this, provided the fix for
                                            // KST-1216
        {
            for (auto* voice : usableVoices)
                if (voice->getCurrentlyPlayingNote() == midiNoteNumber)
                    return voice;
        }
 
        // Oldest voice that has been released (no finger on it and not held by sustain pedal)
        for (auto* voice : usableVoices)
            if (voice != low && voice != top && voice->isPlayingButReleased())
                return voice;
 
        // Oldest voice that doesn't have a finger on it:
        for (auto* voice : usableVoices)
            if (voice != low && voice != top && !voice->isKeyDown())
                return voice;
 
        // Oldest voice that isn't protected
        for (auto* voice : usableVoices)
            if (voice != low && voice != top)
                return voice;
 
        // We've only got "protected" voices now: lowest note takes priority
        jassert(low != nullptr);
 
        // Duophonic synth: give priority to the bass note:
        if (top != nullptr)
            return top;
 
        return low;
    }
 
    void KwidgetSynth::noteOff(int midiChannel, int midiNoteNumber, float velocity, bool allowTailOff)
    {
        Synthesiser::noteOff(midiChannel, midiNoteNumber, velocity, allowTailOff);
        if (midiNoteNumber <= MIDI_NOTE_MASK) // If it is a normal MIDI note number
        {
            noteOnThenDelayedNoteOff(midiChannel, midiNoteNumber + MIDI_NOTE_FLAG_NOR, velocity, allowTailOff);
        }
    }
 
    void KwidgetSynth::timerCallback()
    {
        while (!m_messageBuffer.empty())
        {
            midiMessage mess = m_messageBuffer.back();
            m_messageBuffer.pop_back();
            Synthesiser::noteOff(mess.midiChannel, mess.midiNoteNumber, mess.velocity, mess.allowTailOff);
        }
        stopTimer();
    }
 
    void KwidgetSynth::noteOnThenDelayedNoteOff(int midiChannel, int midiNoteNumber, float velocity, bool allowTailOff)
    {
        Synthesiser::noteOn(midiChannel, midiNoteNumber, velocity);
        m_messageBuffer.push_back(midiMessage{midiChannel, midiNoteNumber, velocity, allowTailOff});
        startTimer(NOTE_UP_NOTE_LENGTH_MS);
    }
 
} // namespace krotos