KwidgetProcessor_Reformer.cpp

Go to the documentation of this file.

namespace krotos
{
    KwidgetProcessor_Reformer::KwidgetProcessor_Reformer(Kwidget& owner, KrotosSampleOscillatorSound& sound)
        : KwidgetProcessor(owner), m_soSound(sound), m_attachmentCache(RGParam::NUM_PARAMS)
    {
        addParameterAttachments({{Parameters::Start, nullptr, -1},        {Parameters::PuckX, nullptr, -1},
                                 {Parameters::PuckY, nullptr, -1},        {Parameters::Nearest, 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::GranularLevel, 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::Popcorn, nullptr, -1},      {Parameters::Quench, nullptr, -1},
                                 {Parameters::Robin, nullptr, -1},        {Parameters::SALoop, nullptr, -1},
                                 {Parameters::Normalise, nullptr, -1},    {Parameters::Autoplay, nullptr, -1},
                                 {Parameters::Shape, nullptr, -1},        {Parameters::GrainMax, nullptr, -1},
                                 {Parameters::Segmentation, nullptr, -1}, {Parameters::FeatureExtr, nullptr, -1},
                                 {Parameters::Mute, nullptr, -1},         {Parameters::Solo, nullptr, -1},
                                 {Parameters::MIDIMode, nullptr, -1},     {Parameters::Tracking, nullptr, -1},
                                 {Parameters::Coeff0, nullptr, -1},       {Parameters::Coeff1, nullptr, -1},
                                 {Parameters::Coeff2, nullptr, -1},       {Parameters::Coeff3, nullptr, -1},
                                 {Parameters::Coeff4, nullptr, -1},       {Parameters::Coeff5, nullptr, -1},
                                 {Parameters::Coeff6, nullptr, -1},       {Parameters::Coeff7, nullptr, -1},
                                 {Parameters::SelectX, nullptr, -1},      {Parameters::SelectY, nullptr, -1},
                                 {Parameters::SelectZ, nullptr, -1},      {Parameters::Proximity, nullptr, -1},
                                 {Parameters::Radius, nullptr, -1}});
 
        // Set up KAttachment* cache
        m_attachmentCache[RGParam::Start] = getAttachment(Parameters::Start);
        m_attachmentCache[RGParam::PuckX] = getAttachment(Parameters::PuckX);
        m_attachmentCache[RGParam::PuckY] = getAttachment(Parameters::PuckY);
        m_attachmentCache[RGParam::Nearest] = getAttachment(Parameters::Nearest);
        m_attachmentCache[RGParam::StartRand] = getAttachment(Parameters::StartRand);
        m_attachmentCache[RGParam::Size] = getAttachment(Parameters::Size);
        m_attachmentCache[RGParam::SizeRand] = getAttachment(Parameters::SizeRand);
        m_attachmentCache[RGParam::Rate] = getAttachment(Parameters::Rate);
        m_attachmentCache[RGParam::RateRand] = getAttachment(Parameters::RateRand);
        m_attachmentCache[RGParam::Width] = getAttachment(Parameters::Width);
        m_attachmentCache[RGParam::WidthRand] = getAttachment(Parameters::WidthRand);
        m_attachmentCache[RGParam::Pan] = getAttachment(Parameters::Pan);
        m_attachmentCache[RGParam::PanRand] = getAttachment(Parameters::PanRand);
        m_attachmentCache[RGParam::Detune] = getAttachment(Parameters::Pitch);
        m_attachmentCache[RGParam::DetuneMod] = getAttachment(Parameters::PitchMod);
        m_attachmentCache[RGParam::DetuneRand] = getAttachment(Parameters::PitchRand);
        m_attachmentCache[RGParam::Level] = getAttachment(Parameters::Level);
        m_attachmentCache[RGParam::GranularLevel] = getAttachment(Parameters::GranularLevel);
        m_attachmentCache[RGParam::LevelMod] = getAttachment(Parameters::LevelMod);
        m_attachmentCache[RGParam::LevelRand] = getAttachment(Parameters::LevelRand);
        m_attachmentCache[RGParam::Popcorn] = getAttachment(Parameters::Popcorn);
        m_attachmentCache[RGParam::Quench] = getAttachment(Parameters::Quench);
        m_attachmentCache[RGParam::Robin] = getAttachment(Parameters::Robin);
        m_attachmentCache[RGParam::SALoop] = getAttachment(Parameters::SALoop);
        m_attachmentCache[RGParam::Shape] = getAttachment(Parameters::Shape);
        m_attachmentCache[RGParam::GrainLim] = getAttachment(Parameters::GrainMax);
        m_attachmentCache[RGParam::Tracking] = getAttachment(Parameters::Tracking);
        m_attachmentCache[RGParam::Normalise] = getAttachment(Parameters::Normalise);
        m_attachmentCache[RGParam::Mute] = getAttachment(Parameters::Mute);
        m_attachmentCache[RGParam::Solo] = getAttachment(Parameters::Solo);
        m_attachmentCache[RGParam::Autoplay] = getAttachment(Parameters::Autoplay);
        m_attachmentCache[RGParam::Proximity] = getAttachment(Parameters::Proximity);
        m_attachmentCache[RGParam::Radius] = getAttachment(Parameters::Radius);
 
        m_oscillator.setSampleData(m_soSound.getSampleEngine());
    }
 
    void KwidgetProcessor_Reformer::prepare(double sampleRate, int samplesPerBlock)
    {
        m_soSound.Prepare(30, static_cast<float>(sampleRate));
        m_oscillator.setSampleRate(sampleRate);
        m_oscillator.setBlockSize(static_cast<size_t>(samplesPerBlock));
    }
 
    void KwidgetProcessor_Reformer::process(AudioBuffer<float>& buffer)
    {
        String accessID = "Reformer::process::" + getKwidgetID();
        if (m_soSound.requestAccess(accessID))
        {
            processBlockInternal(buffer);
 
            m_soSound.finishedAccessing(accessID);
        }
        else
        {
            auto numSamples = buffer.getNumSamples();
            nextBlock(numSamples);
        }
    }
 
    bool KwidgetProcessor_Reformer::isActive()
    {
        // We always return active so we can hold onto the voice even
        // when playing grains sparsely (ie there is silence between grains)
        // In addition, in popcorn mode grains may stop playing when the user
        // stops moving the puck, so we need to hold onto the voice so that
        // playing can resume if the user resumes moving the puck
        // The voice will ultimately be terminated in these cases when the
        // child kwidget ADSR times out at the end of its cycle
        return true;
    }
 
    void KwidgetProcessor_Reformer::processBlockInternal(AudioBuffer<float>& buffer)
    {
        auto numSamples = buffer.getNumSamples();
        auto numChannels = buffer.getNumChannels();
        auto bufferPtr = const_cast<float**>(buffer.getArrayOfWritePointers());
 
        nextBlock(numSamples);
 
        m_oscillator.setGranularParameter(RGParam::Start, m_attachmentCache[RGParam::Start]->data());
        m_oscillator.setGranularParameter(RGParam::PuckX, m_attachmentCache[RGParam::PuckX]->data());
        m_oscillator.setGranularParameter(RGParam::PuckY, m_attachmentCache[RGParam::PuckY]->data());
        m_oscillator.setGranularParameter(RGParam::Nearest, m_attachmentCache[RGParam::Nearest]->data());
        m_oscillator.setGranularParameter(RGParam::StartRand, m_attachmentCache[RGParam::StartRand]->data());
        m_oscillator.setGranularParameter(RGParam::Size, m_attachmentCache[RGParam::Size]->data());
        m_oscillator.setGranularParameter(RGParam::SizeRand, m_attachmentCache[RGParam::SizeRand]->data());
        m_oscillator.setGranularParameter(RGParam::Rate, m_attachmentCache[RGParam::Rate]->data());
        m_oscillator.setGranularParameter(RGParam::RateRand, m_attachmentCache[RGParam::RateRand]->data());
        m_oscillator.setGranularParameter(RGParam::Width, m_attachmentCache[RGParam::Width]->data());
        m_oscillator.setGranularParameter(RGParam::WidthRand, m_attachmentCache[RGParam::WidthRand]->data());
        m_oscillator.setGranularParameter(RGParam::Pan, m_attachmentCache[RGParam::Pan]->data());
        m_oscillator.setGranularParameter(RGParam::PanRand, m_attachmentCache[RGParam::PanRand]->data());
        m_oscillator.setGranularParameter(RGParam::Detune, m_attachmentCache[RGParam::Detune]->data());
        m_oscillator.setGranularParameter(RGParam::DetuneMod, m_attachmentCache[RGParam::DetuneMod]->data());
        m_oscillator.setGranularParameter(RGParam::DetuneRand, m_attachmentCache[RGParam::DetuneRand]->data());
        m_oscillator.setGranularParameter(RGParam::Level, m_attachmentCache[RGParam::Level]->data());
        m_oscillator.setGranularParameter(RGParam::GranularLevel, m_attachmentCache[RGParam::GranularLevel]->data());
        m_oscillator.setGranularParameter(RGParam::LevelMod, m_attachmentCache[RGParam::LevelMod]->data());
        m_oscillator.setGranularParameter(RGParam::LevelRand, m_attachmentCache[RGParam::LevelRand]->data());
        m_oscillator.setGranularParameter(RGParam::Popcorn, m_attachmentCache[RGParam::Popcorn]->data());
        m_oscillator.setGranularParameter(RGParam::Quench, m_attachmentCache[RGParam::Quench]->data());
        m_oscillator.setGranularParameter(RGParam::Robin, m_attachmentCache[RGParam::Robin]->data());
        m_oscillator.setGranularParameter(RGParam::SALoop, m_attachmentCache[RGParam::SALoop]->data());
        m_oscillator.setGranularParameter(RGParam::Shape, m_attachmentCache[RGParam::Shape]->data());
        m_oscillator.setGranularParameter(RGParam::GrainLim, m_attachmentCache[RGParam::GrainLim]->data());
        m_oscillator.setGranularParameter(RGParam::Tracking, m_attachmentCache[RGParam::Tracking]->data());
        m_oscillator.setGranularParameter(RGParam::Normalise, m_attachmentCache[RGParam::Normalise]->data());
        m_oscillator.setGranularParameter(RGParam::Mute, m_attachmentCache[RGParam::Mute]->data());
        m_oscillator.setGranularParameter(RGParam::Solo, m_attachmentCache[RGParam::Solo]->data());
        m_oscillator.setGranularParameter(RGParam::Autoplay, m_attachmentCache[RGParam::Autoplay]->data());
        m_oscillator.setGranularParameter(RGParam::Proximity, m_attachmentCache[RGParam::Proximity]->data());
        m_oscillator.setGranularParameter(RGParam::Radius, m_attachmentCache[RGParam::Radius]->data());
 
        Point<float> puckPosition(m_attachmentCache[RGParam::PuckX]->data()[0],
                                  m_attachmentCache[RGParam::PuckY]->data()[0]);
        m_soSound.getSampleEngine()->setPuckPosition(puckPosition);
 
        float velocity = m_oscillator.getVelocity();
 
        // Get current Mute Param value
        float muteValue = m_attachmentCache[RGParam::Mute]->data()[0];
 
        if (numChannels == 1) // mono
        {
            for (size_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
            {
                nextSample();
                auto samp = m_oscillator.getNextStereoSample(sampleIndex) * velocity;
                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_Reformer::processMuteStereo(float currentMuteValue, int numSamples, float velocity,
                                                      float** bufferPtr)
    {
        if (currentMuteValue == 1.0f) // mute activated
        {
            if (m_formerMuteVal < currentMuteValue && m_formerMuteVal > 0.0f) // 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;
                    bufferPtr[0][sampleIndex] = samp.left;
                    bufferPtr[1][sampleIndex] = samp.right;
                }
            }
            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;
                    bufferPtr[0][sampleIndex] = samp.left;
                    bufferPtr[1][sampleIndex] = samp.right;
                }
            }
        }
        else // mute not activated
        {
            if (m_formerMuteVal > currentMuteValue && currentMuteValue > 0.5f) // 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;
                    bufferPtr[0][sampleIndex] = samp.left;
                    bufferPtr[1][sampleIndex] = samp.right;
                }
            }
            else // we were unmuted
            {
                for (size_t sampleIndex = 0; sampleIndex < numSamples; sampleIndex++)
                {
                    nextSample();
                    auto samp = m_oscillator.getNextStereoSample(sampleIndex) * velocity;
                    bufferPtr[0][sampleIndex] = samp.left;
                    bufferPtr[1][sampleIndex] = samp.right;
                }
            }
        }
    }
 
    void KwidgetProcessor_Reformer::noteOn(int midiNote, float velocity, int voiceIndex)
    {
        m_oscillator.setGranularParameter(ReformerOscillator::GranularParam::Autoplay,
                                          m_attachmentCache[RGParam::Autoplay]->data());
        m_oscillator.startNote(midiNote, velocity, voiceIndex);
    }
 
    void KwidgetProcessor_Reformer::noteOff(float) { m_oscillator.stopNote(); }
 
    void KwidgetProcessor_Reformer::noteCleared() { m_oscillator.clearNote(); }
} // namespace krotos