SampleEngine.h

Go to the documentation of this file.

/*
==============================================================================
 
SampleEngine.h
Created: 16 Oct 2020 13:03:00pm
Author:  sandyw
 
==============================================================================
*/
 
#pragma once
 
namespace krotos
{
    struct AudioSegment
    {
        String name;       // The name of this segment's audio sample
        String path;       // The path to this segment's audio sample
        int sampleRate{0}; // Sample rate of this segment
        float normalisationFactor{
                1.0f}; // A factor which when multiplied with this segments audio will normalise its amplitude
        int segmentStartPosition{0}; // Start of this segment
        int segmentLength{0};        // Length of this segment
 
        // Thread Safety Notice:
        // Previously declared as volatile atomic, these fields (selectionStartPosition, selectionLength)
        // are accessed by both UI and audio threads. PR krotos_modules_3: #553 removed atomic qualifiers
        // based on discussions that deemed the potential race condition unlikely to impact performance significantly.
        // Future changes or observed issues should revisit thread safety measures as discussed in KST-2288.
 
        volatile int selectionStartPosition{0}; // Start of this selection
        volatile int selectionLength{0};        // Length of this selection
        volatile bool muted{false};
        Value solo;
    };
 
    enum class GranularPlaybackMode
    {
        MSampler = 0,
        MGranular,
        MVehicle,
        NUM_MODES
    };
 
    enum class MIDIMode
    {
        All = 0,
        C3,
        CS3,
        D3,
        DS3,
        E3,
        F3,
        FS3,
        G3,
        GS3,
        A3,
        AS3,
        B3,
        C4,
        CS4,
        D4,
        DS4,
        E4,
        F4,
        FS4,
        G4,
        GS4,
        A4,
        AS4,
        B4,
        NUM_MODES
    };
 
    class SampleEngine : public KrotosAudioBufferDSP
    {
      public:
        void newBlockStart() {}
 
        static const int MAX_NUM_GRAINS{200};
 
        void calculatePolyphonyCount();
 
        bool isPlaying();
 
        bool shouldUpdateDisplay()
        {
            if (m_updateDisplayTrigger)
            {
                m_updateDisplayTrigger = false; // Cancel the trigger
                return true;
            }
 
            return isPlaying() || getProgressTracker().isLoading();
        }
 
        void triggerDisplayUpdate() { m_updateDisplayTrigger = true; }
 
        bool hasDisplayUpdated() const { return m_updateDisplayTrigger; }
 
        Grain* allocateGrain();
        void setGrainLimit(int newLimit);
        void freeGrain(Grain* grain);
        Grain* getGrainArray();
        void flushGrains();
 
        void setPuckPosition(Point<float> position) { m_puckPosition = position; }
 
        Point<float> getPuckPosition() { return m_puckPosition; }
 
        void requestAnalysis() { m_AnalysisRequested = true; }
 
        void setGranularOscillatorTypeIndicator(GranularPlaybackMode newType) { m_oscillatorTypeIndicator = newType; }
 
        GranularPlaybackMode getGranularOscillatorTypeIndicator() { return m_oscillatorTypeIndicator; }
 
        void setGranularOscillatorMIDIMode(MIDIMode newMode) { m_oscillatorMIDIMode = newMode; }
 
        MIDIMode getGranularOscillatorMIDIMode() { return m_oscillatorMIDIMode; }
 
        float getIndicator1();
        void setIndicator1(float newVal);
 
        float getIndicator2();
        void setIndicator2(float newVal);
 
        float getIndicatorRPM();
        void setIndicatorRPM(float newVal);
 
        void clearAudioSegments();
        void addAudioSegment(AudioSegment& seg);
 
        int getNumAudioSegments() { return m_audioSegments.size(); }
 
        StringArray getAudioSegmentNames() const;
 
        const Array<AudioSegment>& getAudioSegments() const { return m_audioSegments; }
 
        Range<float> getPlayingWaveformZoomRange()
        {
            Range<float> zoomRange(0.f, 1.f);
 
            /*
            if (getNumAudioSegments() > 1)
            {
                    int currentlyPlayingSegment =
            getSegmentRoundRobinIndex();
                    zoomRange.setStart(getAudioSegmentStartPositionPercent(currentlyPlayingSegment));
                    zoomRange.setEnd(getAudioSegmentEndPositionPercent(currentlyPlayingSegment));
            }
            */
            return zoomRange;
        }
 
        // Audio segmentation methods
 
        // Getters:
        int getAudioSelectionStartPosition(int segmentIndex);
        int getAudioSelectionLengthInSamples(int segmentIndex);
        int getAudioSegmentStartPosition(int segmentIndex);
        int getAudioSegmentLengthInSamples(int segmentIndex);
 
        // Setters:
        void setAudioSelectionRangeRelative(int segmentIndex, Range<int> range);
        void setAudioSelectionStartPositionAbsolute(int segmentIndex, int startPosition);
        void setAudioSelectionLength(int segmentIndex, int length);
 
        std::vector<Range<int>> getSelectionRanges();
        void setSelectionRanges(const std::vector<Range<int>>& selectionRanges);
 
        void setSegmentMuted(int segmentIndex, bool isMuted);
 
        Value& getSoloValue(int index);
 
        juce::String getGetLoadedFilePathsAsCSV();
 
        int getAudioSegmentSampleRate(int segmentIndex)
        {
            int numSegments = m_audioSegments.size();
            if (numSegments)
            {
                return m_audioSegments[segmentIndex % numSegments].sampleRate;
            }
            else
            {
                return 0;
            }
        }
 
        float getAudioSegmentNormalisationFactor(int segmentIndex)
        {
            int numSegments = m_audioSegments.size();
            if (numSegments)
            {
                return m_audioSegments[segmentIndex % numSegments].normalisationFactor;
            }
            else
            {
                return 0;
            }
        }
 
        void setNextSegmentIndex(int index);
 
        void prepareNextSegmentIndex(bool sequential = true);
 
        String getNextCuedSegmentName() const;
 
        const int getNextSegmentIndex() const;
        const int getCurrentSegmentIndex() const { return m_segmentRoundRobinIndex; };
 
        const int getLastSegmentIndex() const;
 
        void removeSegment(int segmentIndex);
 
      private:
        // Setters
        void setAudioSelectionRangeAbsolute(int segmentIndex, Range<int> range);
        void setAudioSegmentStartPosition(int segmentIndex, int startPosition);
        void setAudioSegmentLength(int segmentIndex, int length);
        void setAudioSegmentRange(int segmentIndex, Range<int> range);
 
        // Getters
        Range<int> getAudioSegmentRange(int segmentIndex);
        float getAudioSegmentStartPositionPercent(int segmentIndex);
        float getAudioSegmentEndPositionPercent(int segmentIndex);
        float getAudioSelectionStartPositionPercent(int segmentIndex);
        float getAudioSelectionEndPositionPercent(int segmentIndex);
        Range<int> getAudioSelectionRange(int segmentIndex);
        Range<int> getAudioSelectionRangeRelative(int segmentIndex);
        const String& getAudioSegmentName(int segmentIndex) const;
 
        bool allSegmentsMuted();
 
        bool m_updateDisplayTrigger{false};
        volatile bool m_advancedMode{false};
        Point<float> m_puckPosition{0.f, 0.f};
        GranularPlaybackMode m_oscillatorTypeIndicator{GranularPlaybackMode::MSampler};
        MIDIMode m_oscillatorMIDIMode{MIDIMode::All};
 
        volatile bool m_AnalysisRequested{false};
        volatile bool m_AnalysisInProgress{false};
 
        int m_currentPolyphony{0};
        Grain m_grainArray[MAX_NUM_GRAINS];
        int m_grainLimit{MAX_NUM_GRAINS};
 
        volatile float m_indicator1Value{0.f};
        volatile float m_indicator2Value{0.f};
        volatile float m_indicatorRPMValue{0.f};
 
        Array<AudioSegment> m_audioSegments;
 
        int m_segmentRoundRobinIndex{0};
        int m_lastSegmentRoundRobinIndex{-1};
 
        bool m_allSegmentsMuted{false};
        int m_skippedSegmentIndex{-1};
    };
} // namespace krotos