tracktion_ReadAheadTimeStretcher.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion::inline engine
{
 
//==============================================================================
//==============================================================================
class ReadAheadTimeStretcher
{
public:
    ReadAheadTimeStretcher (int numBlocksToReadAhead);
 
    ~ReadAheadTimeStretcher();
 
    //==============================================================================
    void initialise (double sourceSampleRate, int samplesPerBlock,
                     int numChannels, TimeStretcher::Mode, TimeStretcher::ElastiqueProOptions,
                     bool realtime);
 
    bool isInitialised() const;
 
    void reset();
 
    bool setSpeedAndPitch (float speedRatio, float semitones);
 
    int getMaxFramesNeeded() const;
 
    int getFramesNeeded() const;
 
    int getFramesRecomended() const;
 
    bool requiresMoreFrames() const;
 
    int getFreeSpace() const;
 
    int pushData (const float* const* inChannels, int numSamples);
 
    int getNumReady() const;
 
    int popData (float* const* outChannels, int numSamples);
 
    int flush (float* const* outChannels);
 
private:
    //==============================================================================
    class ProcessThread
    {
    public:
        ProcessThread();
        ~ProcessThread();
 
        void addInstance (ReadAheadTimeStretcher*);
        void removeInstance (ReadAheadTimeStretcher*);
 
        void flagForProcessing (std::atomic<std::uint64_t>&);
 
    private:
        //==============================================================================
        std::vector<ReadAheadTimeStretcher*> instances;
        std::mutex instancesMutex;
 
        std::thread thread;
        juce::WaitableEvent event;
        std::atomic_flag waitingToExitFlag = ATOMIC_FLAG_INIT;
        std::atomic_flag breakForAddRemoveInstance = ATOMIC_FLAG_INIT;
        std::atomic<std::uint64_t> processEpoch { 0 };
 
        //==============================================================================
        void process();
    };
 
    AudioFifo inputFifo { 1, 32 }, outputFifo { 1, 32 };
    mutable TimeStretcher stretcher;
    const int numBlocksToReadAhead;
    int numChannels = 0, numSamplesPerOutputBlock = 0;
    mutable std::mutex processMutex;
    std::atomic<std::uint64_t> epoch { std::numeric_limits<std::uint64_t>::max() };
 
    mutable std::atomic<float> pendingSpeedRatio { 1.0f }, pendingSemitonesUp { 0.0f };
    mutable std::atomic<bool> newSpeedAndPitchPending { false }, hasBeenReset { true };
 
    juce::SharedResourcePointer<ProcessThread> processThread;
 
    void tryToSetNewSpeedAndPitch() const;
    int processNextBlock (bool shouldBlock);
    bool canProcessNextBlock();
    std::uint64_t getEpoch() const { return epoch.load (std::memory_order_acquire); }
};
 
}