SampleEngine.cpp

Go to the documentation of this file.

#include "SampleEngine.h"
namespace krotos
{
    void SampleEngine::calculatePolyphonyCount()
    {
        int polycount = 0;
        for (auto& grain : m_grainArray)
        {
            if (grain.isPlaying)
            {
                polycount++;
            }
        }
        m_currentPolyphony = polycount;
    }
 
    bool SampleEngine::isPlaying()
    {
        bool ret = false;
        for (auto& grain : m_grainArray)
        {
            if (grain.isPlaying)
            {
                ret = true;
                break;
            }
        }
        return ret;
    }
 
    Grain* SampleEngine::allocateGrain()
    {
        Grain* retVal = nullptr;
 
        if (m_currentPolyphony >= m_grainLimit) // If we have reached the grain limit, we wont return a grain slot ...
        {
            // ... however we still have to update m_currentPolyphony or it will get stuck failing
            calculatePolyphonyCount();
            return retVal;
        }
 
        int i = 0;
        for (; i < MAX_NUM_GRAINS; i++)
        {
            if (!m_grainArray[i].isPlaying) // Find a grain slot that's not playing
            {
                m_grainArray[i].isPlaying = true; // Switch it on
                retVal = &m_grainArray[i];
                break;
            }
        }
        int polycount = i;
        for (; i < MAX_NUM_GRAINS; i++)
        {
            if (m_grainArray[i].isPlaying) // Count the remaining grain slots which are playing
            {
                polycount++;
            }
        }
        m_currentPolyphony = polycount;
        return retVal;
    }
 
    void SampleEngine::setGrainLimit(int newLimit) { m_grainLimit = newLimit; }
 
    void SampleEngine::freeGrain(Grain* grain)
    {
        jassert(grain->isPlaying);
        grain->isPlaying = false;
        calculatePolyphonyCount();
    }
 
    Grain* SampleEngine::getGrainArray() { return m_grainArray; }
 
    void SampleEngine::flushGrains()
    {
        for (int i = 0; i < MAX_NUM_GRAINS; i++)
        {
            m_grainArray[i].isPlaying = false;
        }
        m_currentPolyphony = 0;
    }
 
    float SampleEngine::getIndicator1() { return m_indicator1Value; }
    void SampleEngine::setIndicator1(float newVal) { m_indicator1Value = newVal; }
 
    float SampleEngine::getIndicator2() { return m_indicator2Value; }
    void SampleEngine::setIndicator2(float newVal) { m_indicator2Value = newVal; }
 
    float SampleEngine::getIndicatorRPM() { return m_indicatorRPMValue; }
    void SampleEngine::setIndicatorRPM(float newVal) { m_indicatorRPMValue = newVal; }
 
    void SampleEngine::clearAudioSegments() { m_audioSegments.clearQuick(); }
    void SampleEngine::addAudioSegment(AudioSegment& seg) { m_audioSegments.add(seg); }
 
    std::vector<Range<int>> SampleEngine::getSelectionRanges()
    {
        std::vector<Range<int>> ranges;
        for (int segmentIndex = 0; segmentIndex < getNumAudioSegments(); segmentIndex++)
        {
            ranges.push_back(getAudioSelectionRangeRelative(segmentIndex));
        }
        return ranges;
    }
 
    void SampleEngine::setSelectionRanges(const std::vector<Range<int>>& ranges)
    {
        jassert(ranges.size() == getNumAudioSegments());
        for (int i = 0; i < jmin(getNumAudioSegments(), (int)ranges.size()); i++)
        {
            if (!ranges[i].isEmpty())
            {
                setAudioSelectionRangeRelative(i, ranges[i]);
            }
        }
    }
 
    void SampleEngine::setAudioSegmentStartPosition(int segmentIndex, int startPosition)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        m_audioSegments.data()[segmentIndex].segmentStartPosition = startPosition;
    }
 
    void SampleEngine::setAudioSegmentLength(int segmentIndex, int length)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        m_audioSegments.data()[segmentIndex].segmentLength = length;
    }
 
    void SampleEngine::setAudioSegmentRange(int segmentIndex, Range<int> range)
    {
        setAudioSegmentStartPosition(segmentIndex, range.getStart());
        setAudioSegmentLength(segmentIndex, range.getLength());
    }
 
    float SampleEngine::getAudioSegmentStartPositionPercent(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return static_cast<float>(m_audioSegments[segmentIndex].segmentStartPosition) / static_cast<float>(size());
    }
 
    float SampleEngine::getAudioSegmentEndPositionPercent(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return static_cast<float>(m_audioSegments[segmentIndex].segmentStartPosition +
                                  m_audioSegments[segmentIndex].segmentLength) /
               static_cast<float>(size());
    }
 
    Range<int> SampleEngine::getAudioSelectionRange(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return Range<int>(m_audioSegments[segmentIndex].selectionStartPosition,
                          m_audioSegments[segmentIndex].selectionStartPosition +
                                  m_audioSegments[segmentIndex].selectionLength);
    }
 
    Range<int> SampleEngine::getAudioSelectionRangeRelative(int segmentIndex)
    {
        int segmentStart = getAudioSegmentRange(segmentIndex).getStart();
        return getAudioSelectionRange(segmentIndex) - segmentStart;
    }
 
    const String& SampleEngine::getAudioSegmentName(int segmentIndex) const
    {
        return m_audioSegments[segmentIndex].name;
    }
 
    float SampleEngine::getAudioSelectionStartPositionPercent(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return static_cast<float>(m_audioSegments[segmentIndex].selectionStartPosition) / static_cast<float>(size());
    }
 
    float SampleEngine::getAudioSelectionEndPositionPercent(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return static_cast<float>(m_audioSegments[segmentIndex].selectionStartPosition +
                                  m_audioSegments[segmentIndex].selectionLength) /
               static_cast<float>(size());
    }
 
    void SampleEngine::setAudioSelectionRangeAbsolute(int segmentIndex, Range<int> range)
    {
        setAudioSelectionStartPositionAbsolute(segmentIndex, range.getStart());
        setAudioSelectionLength(segmentIndex, range.getLength());
    }
 
    void SampleEngine::setAudioSelectionRangeRelative(int segmentIndex, Range<int> range)
    {
        // Because the selection range is passed in relative to the segment
        // we first offset it so it is relative to the start of the audio buffer
        range = range + getAudioSegmentStartPosition(segmentIndex);
        auto limits = getAudioSegmentRange(segmentIndex);
        auto constrained = limits.constrainRange(range); // Constrain inputRange to the segment
        jassert(range == constrained);                   // Assert if inputRange was not entirely inside the segment
        setAudioSelectionRangeAbsolute(segmentIndex, constrained);
    }
 
    void SampleEngine::setAudioSelectionStartPositionAbsolute(int segmentIndex, int startPosition)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        m_audioSegments.data()[segmentIndex].selectionStartPosition = startPosition;
    }
 
    void SampleEngine::setAudioSelectionLength(int segmentIndex, int length)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        m_audioSegments.data()[segmentIndex].selectionLength = length;
    }
 
    String SampleEngine::getGetLoadedFilePathsAsCSV()
    {
        String filePathsAsCSV;
 
        bool firstTime = true;
        for (auto& segment : m_audioSegments)
        {
            if (firstTime)
            {
                firstTime = false;
            }
            else
            {
                filePathsAsCSV += ",";
            }
            filePathsAsCSV += segment.path;
        }
 
        return filePathsAsCSV;
    }
 
    StringArray SampleEngine::getAudioSegmentNames() const
    {
        StringArray names;
        for (auto& segment : m_audioSegments)
        {
            names.add(segment.name);
        }
        return names;
    }
 
    int SampleEngine::getAudioSelectionStartPosition(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return m_audioSegments[segmentIndex].selectionStartPosition;
    }
 
    int SampleEngine::getAudioSelectionLengthInSamples(int segmentIndex)
    {
        int numSegments = m_audioSegments.size();
        if (numSegments)
        {
            jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
            return m_audioSegments[segmentIndex].selectionLength;
        }
        else
        {
            return 0;
        }
    }
 
    int SampleEngine::getAudioSegmentStartPosition(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return m_audioSegments[segmentIndex].segmentStartPosition;
    }
 
    int SampleEngine::getAudioSegmentLengthInSamples(int segmentIndex)
    {
        int numSegments = m_audioSegments.size();
        if (numSegments)
        {
            jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
            return m_audioSegments[segmentIndex].segmentLength;
        }
        else
        {
            return 0;
        }
    }
 
    Range<int> SampleEngine::getAudioSegmentRange(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        return Range<int>(m_audioSegments[segmentIndex].segmentStartPosition,
                          m_audioSegments[segmentIndex].segmentStartPosition +
                                  m_audioSegments[segmentIndex].segmentLength);
    }
 
    void SampleEngine::setNextSegmentIndex(int segmentIndex)
    {
        const int segmentCount = std::distance(m_audioSegments.begin(), m_audioSegments.end());
 
        if (segmentCount <= segmentIndex || segmentIndex < 0)
        {
            jassertfalse; // Segment index out of range
            return;
        }
 
        if (m_audioSegments.data()[segmentIndex].muted)
        {
            // Won't cue a muted sample
            return;
        }
 
        m_segmentRoundRobinIndex = segmentIndex;
    }
 
    void SampleEngine::removeSegment(int segmentIndex)
    {
        jassert(segmentIndex >= 0 && segmentIndex < m_audioSegments.size());
        m_audioSegments.remove(segmentIndex);
 
        // Update allSegmentsMuted flag in case this leaves all segments muted..
        m_allSegmentsMuted = allSegmentsMuted();
    }
 
    void SampleEngine::prepareNextSegmentIndex(bool sequential)
    {
        m_lastSegmentRoundRobinIndex = m_segmentRoundRobinIndex;
 
        int oldSegmentRoundRobinIndex = m_segmentRoundRobinIndex;
 
        if (m_audioSegments.size() <= 1)
        {
            m_segmentRoundRobinIndex = 0;
        }
        else if (sequential)
        {
            m_segmentRoundRobinIndex++;
            if (m_segmentRoundRobinIndex >= static_cast<int>(m_audioSegments.size()))
            {
                m_segmentRoundRobinIndex = 0;
            }
        }
        else
        {
            if (m_audioSegments.size() > 1)
            {
                do
                {
                    m_segmentRoundRobinIndex =
                            juce::Random::getSystemRandom().nextInt(static_cast<int>(m_audioSegments.size()));
                } while (m_segmentRoundRobinIndex == oldSegmentRoundRobinIndex);
            }
            else
            {
                m_segmentRoundRobinIndex = 0;
            }
        }
 
        if (m_segmentRoundRobinIndex < static_cast<int>(m_audioSegments.size()) &&
            m_audioSegments[m_segmentRoundRobinIndex].muted && !m_allSegmentsMuted)
        {
            prepareNextSegmentIndex(sequential);
        }
    }
 
    bool SampleEngine::allSegmentsMuted()
    {
        for (auto& segment : m_audioSegments)
        {
            if (!segment.muted)
            {
                return false;
            }
        }
        return true;
    }
 
    void SampleEngine::setSegmentMuted(int segmentIndex, bool isMuted)
    {
        const int segmentCount = std::distance(m_audioSegments.begin(), m_audioSegments.end());
 
        if (segmentCount <= segmentIndex || segmentIndex < 0)
        {
            jassertfalse; // Segment index out of range
            return;
        }
 
        if (!m_audioSegments.data()[segmentIndex].solo.getValue())
        {
            m_audioSegments.data()[segmentIndex].muted = isMuted;
        }
 
        m_allSegmentsMuted = allSegmentsMuted();
 
        if (m_segmentRoundRobinIndex >= 0 && m_segmentRoundRobinIndex < segmentCount)
        {
            // Recalculate the segment index if the next sample to play has been muted
            if (m_audioSegments.data()[m_segmentRoundRobinIndex].muted)
            {
                m_skippedSegmentIndex = m_segmentRoundRobinIndex;
                prepareNextSegmentIndex(true);
            }
        }
 
        if (m_skippedSegmentIndex >= 0 && m_skippedSegmentIndex < segmentCount)
        {
            // If the last cued sample was skipped because it was muted, and has since been unmuted, re-cue it
            if (segmentIndex == m_skippedSegmentIndex && !isMuted &&
                !m_audioSegments.data()[m_skippedSegmentIndex].muted)
            {
                setNextSegmentIndex(m_skippedSegmentIndex);
                m_skippedSegmentIndex = -1;
            }
        }
    }
 
    String SampleEngine::getNextCuedSegmentName() const { return getAudioSegmentName(m_segmentRoundRobinIndex); }
 
    const int SampleEngine::getNextSegmentIndex() const { return m_segmentRoundRobinIndex; }
    const int SampleEngine::getLastSegmentIndex() const { return m_lastSegmentRoundRobinIndex; }
 
    Value& SampleEngine::getSoloValue(int index) { return m_audioSegments.data()[index].solo; }
} // namespace krotos