KwidgetProcessor_CoreEngine.cpp

Go to the documentation of this file.

namespace krotos
{
    using Parameters = Kwidget_CoreEngine::Parameters;
 
    KwidgetProcessor_CoreEngine::KwidgetProcessor_CoreEngine(Kwidget& owner, KrotosSampleOscillatorSound& sound)
        : KwidgetProcessor(owner), m_soSound(sound), m_attachmentCache(GParam::NUM_PARAMS)
    {
        addParameterAttachments({{Parameters::Start, nullptr, -1},
                                 {Parameters::Size, nullptr, -1},
                                 {Parameters::Rate, nullptr, -1},
                                 {Parameters::Pitch, nullptr, -1},
                                 {Parameters::PitchMod, nullptr, -1},
                                 {Parameters::Width, nullptr, -1},
                                 {Parameters::Pan, nullptr, -1},
                                 {Parameters::Level, nullptr, -1},
                                 {Parameters::SamplerLevel, nullptr, -1},
                                 {Parameters::GranularLevel, nullptr, -1},
                                 {Parameters::VehicleLevel, nullptr, -1},
                                 {Parameters::LevelMod, nullptr, -1},
                                 {Parameters::StartRand, nullptr, -1},
                                 {Parameters::SizeRand, nullptr, -1},
                                 {Parameters::RateRand, nullptr, -1},
                                 {Parameters::PitchRand, nullptr, -1},
                                 {Parameters::WidthRand, nullptr, -1},
                                 {Parameters::PanRand, nullptr, -1},
                                 {Parameters::LevelRand, nullptr, -1},
                                 {Parameters::Quench, nullptr, -1},
                                 {Parameters::Robin, nullptr, -1},
                                 {Parameters::SALoop, nullptr, -1},
                                 {Parameters::AutoRate, nullptr, -1},
                                 {Parameters::PhaseLock, nullptr, -1},
                                 {Parameters::PhaseSync, nullptr, -1},
                                 {Parameters::Normalise, nullptr, -1},
                                 {Parameters::MuteUp, nullptr, -1},
                                 {Parameters::MuteDown, nullptr, -1},
                                 {Parameters::Autoplay, nullptr, -1},
                                 {Parameters::Shape, nullptr, -1},
                                 {Parameters::GrainMax, nullptr, -1},
                                 {Parameters::Tracking, nullptr, -1},
                                 {Parameters::Cycles, nullptr, -1},
                                 {Parameters::Smoothing, nullptr, -1},
                                 {Parameters::Sensitivity, nullptr, -1},
                                 {Parameters::ASize, nullptr, -1},
                                 {Parameters::ARate, nullptr, -1},
                                 {Parameters::ASpray, nullptr, -1},
                                 {Parameters::AMix, nullptr, -1},
                                 {Parameters::BSize, nullptr, -1},
                                 {Parameters::BRate, nullptr, -1},
                                 {Parameters::BSpray, nullptr, -1},
                                 {Parameters::BMix, nullptr, -1},
                                 {Parameters::Mode, nullptr, -1},
                                 {Parameters::Mute, nullptr, -1},
                                 {Parameters::Solo, nullptr, -1},
                                 {Parameters::MIDIMode, nullptr, -1},
                                 {Parameters::Distance, [this](float x) { setDistance(x); }, 10}});
 
        // Set up a cache vector of KAttachment* indexed by the GranularParameter enum to save cpu spent on map lookups
        // during the process block.
        m_attachmentCache[GParam::Start] = getAttachment(Parameters::Start);
        m_attachmentCache[GParam::StartRand] = getAttachment(Parameters::StartRand);
        m_attachmentCache[GParam::Size] = getAttachment(Parameters::Size);
        m_attachmentCache[GParam::SizeRand] = getAttachment(Parameters::SizeRand);
        m_attachmentCache[GParam::Rate] = getAttachment(Parameters::Rate);
        m_attachmentCache[GParam::RateRand] = getAttachment(Parameters::RateRand);
        m_attachmentCache[GParam::Width] = getAttachment(Parameters::Width);
        m_attachmentCache[GParam::WidthRand] = getAttachment(Parameters::WidthRand);
        m_attachmentCache[GParam::Pan] = getAttachment(Parameters::Pan);
        m_attachmentCache[GParam::PanRand] = getAttachment(Parameters::PanRand);
        m_attachmentCache[GParam::Detune] = getAttachment(Parameters::Pitch);
        m_attachmentCache[GParam::DetuneMod] = getAttachment(Parameters::PitchMod);
        m_attachmentCache[GParam::DetuneRand] = getAttachment(Parameters::PitchRand);
        m_attachmentCache[GParam::Level] = getAttachment(Parameters::Level);
        m_attachmentCache[GParam::SamplerLevel] = getAttachment(Parameters::SamplerLevel);
        m_attachmentCache[GParam::GranularLevel] = getAttachment(Parameters::GranularLevel);
        m_attachmentCache[GParam::VehicleLevel] = getAttachment(Parameters::VehicleLevel);
        m_attachmentCache[GParam::LevelMod] = getAttachment(Parameters::LevelMod);
        m_attachmentCache[GParam::LevelRand] = getAttachment(Parameters::LevelRand);
        m_attachmentCache[GParam::Quench] = getAttachment(Parameters::Quench);
        m_attachmentCache[GParam::Robin] = getAttachment(Parameters::Robin);
        m_attachmentCache[GParam::SALoop] = getAttachment(Parameters::SALoop);
        m_attachmentCache[GParam::AutoRate] = getAttachment(Parameters::AutoRate);
        m_attachmentCache[GParam::Shape] = getAttachment(Parameters::Shape);
        m_attachmentCache[GParam::GrainLim] = getAttachment(Parameters::GrainMax);
        m_attachmentCache[GParam::Tracking] = getAttachment(Parameters::Tracking);
        m_attachmentCache[GParam::Cycles] = getAttachment(Parameters::Cycles);
        m_attachmentCache[GParam::PhaseLock] = getAttachment(Parameters::PhaseLock);
        m_attachmentCache[GParam::PhaseSync] = getAttachment(Parameters::PhaseSync);
        m_attachmentCache[GParam::Normalise] = getAttachment(Parameters::Normalise);
        m_attachmentCache[GParam::MuteUp] = getAttachment(Parameters::MuteUp);
        m_attachmentCache[GParam::MuteDown] = getAttachment(Parameters::MuteDown);
        m_attachmentCache[GParam::Smoothing] = getAttachment(Parameters::Smoothing);
        m_attachmentCache[GParam::MovementSensitivity] = getAttachment(Parameters::Sensitivity);
        m_attachmentCache[GParam::SizeST] = getAttachment(Parameters::ASize);
        m_attachmentCache[GParam::DivST] = getAttachment(Parameters::ARate);
        m_attachmentCache[GParam::SprayST] = getAttachment(Parameters::ASpray);
        m_attachmentCache[GParam::MixST] = getAttachment(Parameters::AMix);
        m_attachmentCache[GParam::SizeDY] = getAttachment(Parameters::BSize);
        m_attachmentCache[GParam::DivDY] = getAttachment(Parameters::BRate);
        m_attachmentCache[GParam::SprayDY] = getAttachment(Parameters::BSpray);
        m_attachmentCache[GParam::MixDY] = getAttachment(Parameters::BMix);
        m_attachmentCache[GParam::Mute] = getAttachment(Parameters::Mute);
        m_attachmentCache[GParam::Solo] = getAttachment(Parameters::Solo);
        m_attachmentCache[GParam::Autoplay] = getAttachment(Parameters::Autoplay);
 
        m_oscillator.setSampleData(m_soSound.getSampleEngine());
    }
 
    void KwidgetProcessor_CoreEngine::prepare(double sampleRate, int samplesPerBlock)
    {
        m_soSound.Prepare(30, static_cast<float>(sampleRate));
        m_oscillator.setSampleRate(sampleRate);
        m_SAFilter.prepare(sampleRate, samplesPerBlock);
    }
 
    void KwidgetProcessor_CoreEngine::process(AudioBuffer<float>& buffer)
    {
        String accessID = "CoreEngine::process::" + getKwidgetID();
        if (m_soSound.requestAccess(accessID))
        {
            processBlockInternal(buffer);
 
            m_soSound.finishedAccessing(accessID);
        }
        else
        {
            auto numSamples = buffer.getNumSamples();
            nextBlock(numSamples);
        }
    }
 
    bool KwidgetProcessor_CoreEngine::isActive()
    {
        if (m_soSound.getSampleEngine()->getGranularOscillatorTypeIndicator() == GranularPlaybackMode::MSampler)
        {
            // If we are in sampler mode, we are only active if the sample engine is playing - ie has active grain/s
            return m_soSound.getSampleEngine()->isPlaying();
        }
        else
        {
            // Otherwise we say we are always active so we can hold onto the voice even when playing grains sparsely
            // ie there is silence between grains
            // The voice will be terminated in this case when the child kwidget, ADSR, times out
            return true;
        }
    }
 
    void KwidgetProcessor_CoreEngine::processBlockInternal(AudioBuffer<float>& buffer)
    {
        auto numSamples = buffer.getNumSamples();
        auto numChannels = buffer.getNumChannels();
        auto bufferPtr = const_cast<float**>(buffer.getArrayOfWritePointers());
 
        nextBlock(numSamples);
 
        m_oscillator.setGranularParameter(GParam::Start, m_attachmentCache[GParam::Start]->data());
        m_oscillator.setGranularParameter(GParam::StartRand, m_attachmentCache[GParam::StartRand]->data());
        m_oscillator.setGranularParameter(GParam::Size, m_attachmentCache[GParam::Size]->data());
        m_oscillator.setGranularParameter(GParam::SizeRand, m_attachmentCache[GParam::SizeRand]->data());
        m_oscillator.setGranularParameter(GParam::Rate, m_attachmentCache[GParam::Rate]->data());
        m_oscillator.setGranularParameter(GParam::RateRand, m_attachmentCache[GParam::RateRand]->data());
        m_oscillator.setGranularParameter(GParam::Width, m_attachmentCache[GParam::Width]->data());
        m_oscillator.setGranularParameter(GParam::WidthRand, m_attachmentCache[GParam::WidthRand]->data());
        m_oscillator.setGranularParameter(GParam::Pan, m_attachmentCache[GParam::Pan]->data());
        m_oscillator.setGranularParameter(GParam::PanRand, m_attachmentCache[GParam::PanRand]->data());
        m_oscillator.setGranularParameter(GParam::Detune, m_attachmentCache[GParam::Detune]->data());
        m_oscillator.setGranularParameter(GParam::DetuneMod, m_attachmentCache[GParam::DetuneMod]->data());
        m_oscillator.setGranularParameter(GParam::DetuneRand, m_attachmentCache[GParam::DetuneRand]->data());
        m_oscillator.setGranularParameter(GParam::Level, m_attachmentCache[GParam::Level]->data());
        m_oscillator.setGranularParameter(GParam::SamplerLevel, m_attachmentCache[GParam::SamplerLevel]->data());
        m_oscillator.setGranularParameter(GParam::GranularLevel, m_attachmentCache[GParam::GranularLevel]->data());
        m_oscillator.setGranularParameter(GParam::VehicleLevel, m_attachmentCache[GParam::VehicleLevel]->data());
        m_oscillator.setGranularParameter(GParam::LevelMod, m_attachmentCache[GParam::LevelMod]->data());
        m_oscillator.setGranularParameter(GParam::LevelRand, m_attachmentCache[GParam::LevelRand]->data());
        m_oscillator.setGranularParameter(GParam::Quench, m_attachmentCache[GParam::Quench]->data());
        m_oscillator.setGranularParameter(GParam::Robin, m_attachmentCache[GParam::Robin]->data());
        m_oscillator.setGranularParameter(GParam::SALoop, m_attachmentCache[GParam::SALoop]->data());
        m_oscillator.setGranularParameter(GParam::AutoRate, m_attachmentCache[GParam::AutoRate]->data());
        m_oscillator.setGranularParameter(GParam::Shape, m_attachmentCache[GParam::Shape]->data());
        m_oscillator.setGranularParameter(GParam::GrainLim, m_attachmentCache[GParam::GrainLim]->data());
        m_oscillator.setGranularParameter(GParam::Tracking, m_attachmentCache[GParam::Tracking]->data());
        m_oscillator.setGranularParameter(GParam::Cycles, m_attachmentCache[GParam::Cycles]->data());
        m_oscillator.setGranularParameter(GParam::PhaseLock, m_attachmentCache[GParam::PhaseLock]->data());
        m_oscillator.setGranularParameter(GParam::PhaseSync, m_attachmentCache[GParam::PhaseSync]->data());
        m_oscillator.setGranularParameter(GParam::MuteUp, m_attachmentCache[GParam::MuteUp]->data());
        m_oscillator.setGranularParameter(GParam::MuteDown, m_attachmentCache[GParam::MuteDown]->data());
        m_oscillator.setGranularParameter(GParam::Normalise, m_attachmentCache[GParam::Normalise]->data());
        m_oscillator.setGranularParameter(GParam::Smoothing, m_attachmentCache[GParam::Smoothing]->data());
        m_oscillator.setGranularParameter(GParam::MovementSensitivity,
                                          m_attachmentCache[GParam::MovementSensitivity]->data());
        m_oscillator.setGranularParameter(GParam::SizeST, m_attachmentCache[GParam::SizeST]->data());
        m_oscillator.setGranularParameter(GParam::DivST, m_attachmentCache[GParam::DivST]->data());
        m_oscillator.setGranularParameter(GParam::SprayST, m_attachmentCache[GParam::SprayST]->data());
        m_oscillator.setGranularParameter(GParam::MixST, m_attachmentCache[GParam::MixST]->data());
        m_oscillator.setGranularParameter(GParam::SizeDY, m_attachmentCache[GParam::SizeDY]->data());
        m_oscillator.setGranularParameter(GParam::DivDY, m_attachmentCache[GParam::DivDY]->data());
        m_oscillator.setGranularParameter(GParam::SprayDY, m_attachmentCache[GParam::SprayDY]->data());
        m_oscillator.setGranularParameter(GParam::MixDY, m_attachmentCache[GParam::MixDY]->data());
        m_oscillator.setGranularParameter(GParam::Mute, m_attachmentCache[GParam::Mute]->data());
        m_oscillator.setGranularParameter(GParam::Solo, m_attachmentCache[GParam::Solo]->data());
        m_oscillator.setGranularParameter(GParam::Autoplay, m_attachmentCache[GParam::Autoplay]->data());
 
        float velocity = m_oscillator.getVelocity();
 
        // Get current Mute Param value
        float muteValue = m_attachmentCache[GParam::Mute]->data()[0];
 
        if (numChannels == 1) // mono
        {
            for (size_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
            {
                nextSample();
                auto samp = m_oscillator.getNextStereoSample(sampleIndex) * velocity;
                m_SAFilter.process((samp.left + samp.right) * 0.5f, 0);
                bufferPtr[0][sampleIndex] = (samp.left + samp.right) * 0.5f;
            }
        }
        else // stereo
        {
            processMuteStereo(muteValue, numSamples, velocity, bufferPtr);
        }
 
        // Update former mute value
        m_formerMuteVal = muteValue;
    }
 
    void KwidgetProcessor_CoreEngine::processMuteStereo(float currentMuteValue, int numSamples, float velocity,
                                                        float** bufferPtr)
    {
        if (currentMuteValue > ParameterManager::OnOffThreshold) // mute activated
        {
            if (m_formerMuteVal <= ParameterManager::OnOffThreshold) // we just changed to mute
            {
                // do ramping down to 0
                for (size_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
                {
                    nextSample();
                    float ramp = sampleIndex / (numSamples - 1.0f);
                    float atten = 1.0f - ramp;
                    auto samp = (m_oscillator.getNextStereoSample(sampleIndex) * velocity) * atten;
                    // here filtering
                    auto leftFiltered = m_SAFilter.process(samp.left, 0);
                    bufferPtr[0][sampleIndex] = leftFiltered;
                    auto rightFiltered = m_SAFilter.process(samp.right, 1);
                    bufferPtr[1][sampleIndex] = rightFiltered;
                }
            }
            else // we were in mute
            {
                // just zero
                for (size_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
                {
                    nextSample();
                    auto samp = m_oscillator.getNextStereoSample(sampleIndex) * velocity * 0.0f;
                    // here filtering
                    auto leftFiltered = m_SAFilter.process(samp.left, 0);
                    bufferPtr[0][sampleIndex] = leftFiltered;
                    auto rightFiltered = m_SAFilter.process(samp.right, 1);
                    bufferPtr[1][sampleIndex] = rightFiltered;
                }
            }
        }
        else // mute not activated
        {
            if (m_formerMuteVal > ParameterManager::OnOffThreshold &&
                currentMuteValue <= ParameterManager::OnOffThreshold) // we just unmuted
            {
                for (size_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
                {
                    nextSample();
                    float ramp = sampleIndex / (numSamples - 1.0f);
                    auto samp = (m_oscillator.getNextStereoSample(sampleIndex) * velocity) * ramp;
                    // here filtering
                    auto leftFiltered = m_SAFilter.process(samp.left, 0);
                    bufferPtr[0][sampleIndex] = leftFiltered;
                    auto rightFiltered = m_SAFilter.process(samp.right, 1);
                    bufferPtr[1][sampleIndex] = rightFiltered;
                }
            }
            else // we were unmuted
            {
                for (size_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
                {
                    nextSample();
                    auto samp = m_oscillator.getNextStereoSample(sampleIndex) * velocity;
                    // here filtering
                    auto leftFiltered = m_SAFilter.process(samp.left, 0);
                    bufferPtr[0][sampleIndex] = leftFiltered;
                    auto rightFiltered = m_SAFilter.process(samp.right, 1);
                    bufferPtr[1][sampleIndex] = rightFiltered;
                }
            }
        }
    }
 
    void KwidgetProcessor_CoreEngine::noteOn(int midiNote, float velocity, int voiceIndex)
    {
        m_oscillator.setGranularParameter(GParam::Autoplay, m_attachmentCache[GParam::Autoplay]->data());
        m_oscillator.startNote(midiNote, velocity, voiceIndex);
    }
 
    void KwidgetProcessor_CoreEngine::noteOff(float) { m_oscillator.stopNote(); }
 
    void KwidgetProcessor_CoreEngine::noteCleared() { m_oscillator.clearNote(); }
 
    void KwidgetProcessor_CoreEngine::setDistance(float distance) { m_SAFilter.setDistance(distance); }
 
} // namespace krotos