tracktion_PlayHead.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.
*/
 
#pragma once
 
 
namespace tracktion { inline namespace graph
{
 
class PlayHead;
 
//==============================================================================
//==============================================================================
struct SplitTimelineRange
{
    SplitTimelineRange (juce::Range<int64_t> range1)
        : timelineRange1 (range1), isSplit (false) {}
 
    SplitTimelineRange (juce::Range<int64_t> range1, juce::Range<int64_t> range2)
        : timelineRange1 (range1), timelineRange2 (range2), isSplit (true) {}
 
    const juce::Range<int64_t> timelineRange1, timelineRange2;
    const bool isSplit;
};
 
 
static inline SplitTimelineRange referenceSampleRangeToSplitTimelineRange (const PlayHead&, juce::Range<int64_t> referenceSampleRange);
 
 
//==============================================================================
//==============================================================================
class PlayHead
{
public:
    PlayHead() noexcept;
 
    //==============================================================================
    void setPosition (int64_t newPosition);
 
    void play (juce::Range<int64_t> rangeToPlay, bool looped);
 
    void play();
 
    void playSyncedToRange (juce::Range<int64_t> rangeToPlay);
 
    void stop();
 
    int64_t getPosition() const;
 
    int64_t getUnloopedPosition() const;
 
    void overridePosition (int64_t newPosition);
 
    //==============================================================================
    bool isPlaying() const noexcept;
 
    bool isStopped() const noexcept;
 
    bool isLooping() const noexcept;
 
    bool isRollingIntoLoop() const noexcept;
 
    juce::Range<int64_t> getLoopRange() const noexcept;
 
    void setLoopRange (bool loop, juce::Range<int64_t> loopRange, bool updatePosition = true);
 
    void setRollInToLoop (int64_t playbackPosition);
 
    //==============================================================================
    void setUserIsDragging (bool);
 
    bool isUserDragging() const;
 
    std::chrono::system_clock::time_point getLastUserInteractionTime() const;
 
    //==============================================================================
    void setScrubbingBlockLength (int64_t numSamples);
 
    int64_t getScrubbingBlockLength() const;
 
    //==============================================================================
    int64_t referenceSamplePositionToTimelinePosition (int64_t referenceSamplePosition) const;
 
    int64_t referenceSamplePositionToTimelinePositionUnlooped (int64_t referenceSamplePosition) const;
 
    juce::Range<int64_t> referenceSampleRangeToSourceRangeUnlooped (juce::Range<int64_t> sourceReferenceSampleRange) const;
 
    static int64_t linearPositionToLoopPosition (int64_t position, juce::Range<int64_t> loopRange);
 
    //==============================================================================
    void setReferenceSampleRange (juce::Range<int64_t> sampleRange);
 
    juce::Range<int64_t> getReferenceSampleRange() const;
 
    int64_t getPlayoutSyncPosition() const;
 
private:
    //==============================================================================
    struct SyncPositions
    {
        SyncPositions() noexcept = default;
        int64_t referenceSyncPosition = 0;
        int64_t playoutSyncPosition = 0;
    };
 
    MultipleWriterSeqLock<SyncPositions> syncPositions;
 
    //==============================================================================
    MultipleWriterSeqLock<juce::Range<int64_t>> referenceSampleRange;
    MultipleWriterSeqLock<juce::Range<int64_t>> timelinePlayRange;
    std::atomic<int64_t> scrubbingBlockLength { static_cast<int64_t> (0.08 * 44100.0) };
 
    std::atomic<int> speed { 0 };
    std::atomic<bool> looping { false }, userDragging { false }, rollInToLoop { false };
 
    std::atomic<std::chrono::system_clock::time_point> userInteractionTime { std::chrono::system_clock::now() };
 
    //==============================================================================
    SyncPositions getSyncPositions() const              { return syncPositions.load(); }
    void setSyncPositions (SyncPositions newPositions)  { syncPositions.store (newPositions); }
 
    void userInteraction()  { userInteractionTime = std::chrono::system_clock::now(); }
};
 
 
//==============================================================================
//==============================================================================
inline PlayHead::PlayHead() noexcept
{
    assert (scrubbingBlockLength.is_lock_free());
}
 
//==============================================================================
inline void PlayHead::setPosition (int64_t newPosition)
{
    if (newPosition != getPosition())
        userInteraction();
 
    overridePosition (newPosition);
}
 
inline void PlayHead::play (juce::Range<int64_t> rangeToPlay, bool looped)
{
    timelinePlayRange.store (rangeToPlay);
    looping = looped && (rangeToPlay.getLength() > 50);
    setPosition (rangeToPlay.getStart());
    speed = 1;
}
 
inline void PlayHead::play()
{
    setPosition (getPosition());
    speed = 1;
}
 
inline void PlayHead::playSyncedToRange (juce::Range<int64_t> rangeToPlay)
{
    play (rangeToPlay, false);
    setSyncPositions ({});
}
 
inline void PlayHead::stop()
{
    auto t = getPosition();
    speed = 0;
    setPosition (t);
}
 
inline int64_t PlayHead::getPosition() const
{
    return referenceSamplePositionToTimelinePosition (referenceSampleRange.load().getStart());
}
 
inline int64_t PlayHead::getUnloopedPosition() const
{
    return referenceSamplePositionToTimelinePositionUnlooped (referenceSampleRange.load().getStart());
}
 
inline void PlayHead::overridePosition (int64_t newPosition)
{
    if (looping && rollInToLoop)
        newPosition = std::min (newPosition, timelinePlayRange.load().getEnd());
    else if (looping)
        newPosition = timelinePlayRange.load().clipValue (newPosition);
 
    SyncPositions newSyncPositions;
    newSyncPositions.referenceSyncPosition = referenceSampleRange.load().getStart();
    newSyncPositions.playoutSyncPosition = newPosition;
    setSyncPositions (newSyncPositions);
}
 
//==============================================================================
inline bool PlayHead::isPlaying() const noexcept                    { return speed.load (std::memory_order_relaxed) != 0; }
 
inline bool PlayHead::isStopped() const noexcept                    { return speed.load (std::memory_order_relaxed) == 0; }
 
inline bool PlayHead::isLooping() const noexcept                    { return looping.load (std::memory_order_relaxed); }
 
inline bool PlayHead::isRollingIntoLoop() const noexcept            { return rollInToLoop.load (std::memory_order_relaxed); }
 
inline juce::Range<int64_t> PlayHead::getLoopRange() const noexcept { return timelinePlayRange.load(); }
 
inline void PlayHead::setLoopRange (bool loop, juce::Range<int64_t> loopRange, bool updatePosition)
{
    if (looping != loop || (loop && loopRange != getLoopRange()))
    {
        auto lastPos = getPosition();
        looping = loop;
        timelinePlayRange.store (loopRange);
 
        if (updatePosition)
            setPosition (lastPos);
    }
}
 
inline void PlayHead::setRollInToLoop (int64_t position)
{
    rollInToLoop = true;
 
    SyncPositions newSyncPositions;
    newSyncPositions.referenceSyncPosition = referenceSampleRange.load().getStart();
    newSyncPositions.playoutSyncPosition = std::min (position, timelinePlayRange.load().getEnd());
    setSyncPositions (newSyncPositions);
}
 
//==============================================================================
inline void PlayHead::setUserIsDragging (bool b)
{
    userInteraction();
    userDragging = b;
}
 
inline bool PlayHead::isUserDragging() const
{
    return userDragging;
}
 
inline std::chrono::system_clock::time_point PlayHead::getLastUserInteractionTime() const
{
    return userInteractionTime;
}
 
//==============================================================================
inline void PlayHead::setScrubbingBlockLength (int64_t numSamples)
{
    scrubbingBlockLength = numSamples;
}
 
inline int64_t PlayHead::getScrubbingBlockLength() const
{
    return scrubbingBlockLength.load (std::memory_order_relaxed);
}
 
//==============================================================================
inline int64_t PlayHead::referenceSamplePositionToTimelinePosition (int64_t referenceSamplePosition) const
{
    const auto syncPos = getSyncPositions();
 
    if (userDragging)
        return syncPos.playoutSyncPosition + ((referenceSamplePosition - syncPos.referenceSyncPosition) % getScrubbingBlockLength());
 
    if (looping && ! rollInToLoop)
        return linearPositionToLoopPosition (referenceSamplePositionToTimelinePositionUnlooped (referenceSamplePosition), timelinePlayRange.load());
 
    return referenceSamplePositionToTimelinePositionUnlooped (referenceSamplePosition);
}
 
inline int64_t PlayHead::referenceSamplePositionToTimelinePositionUnlooped (int64_t referenceSamplePosition) const
{
    const auto syncPos = getSyncPositions();
    return syncPos.playoutSyncPosition + (referenceSamplePosition - syncPos.referenceSyncPosition) * speed;
}
 
inline juce::Range<int64_t> PlayHead::referenceSampleRangeToSourceRangeUnlooped (juce::Range<int64_t> sourceReferenceSampleRange) const
{
    const auto syncPos = getSyncPositions();
    return { syncPos.playoutSyncPosition + (sourceReferenceSampleRange.getStart() - syncPos.referenceSyncPosition) * speed,
             syncPos.playoutSyncPosition + (sourceReferenceSampleRange.getEnd() - syncPos.referenceSyncPosition) * speed };
}
 
inline int64_t PlayHead::linearPositionToLoopPosition (int64_t position, juce::Range<int64_t> loopRange)
{
    const auto loopStart = loopRange.getStart();
    return loopStart + juce::negativeAwareModulo ((position - loopStart), loopRange.getLength());
}
 
//==============================================================================
inline void PlayHead::setReferenceSampleRange (juce::Range<int64_t> sampleRange)
{
    referenceSampleRange.store (sampleRange);
 
    if (rollInToLoop && getPosition() >= timelinePlayRange.load().getStart())
        rollInToLoop = false;
}
 
inline juce::Range<int64_t> PlayHead::getReferenceSampleRange() const
{
    return referenceSampleRange.load();
}
 
inline int64_t PlayHead::getPlayoutSyncPosition() const
{
    return getSyncPositions().playoutSyncPosition;
}
 
//==============================================================================
//==============================================================================
inline SplitTimelineRange referenceSampleRangeToSplitTimelineRange (const PlayHead& playHead, juce::Range<int64_t> referenceSampleRange)
{
    const auto unloopedRange = playHead.referenceSampleRangeToSourceRangeUnlooped (referenceSampleRange);
    auto s = unloopedRange.getStart();
    auto e = unloopedRange.getEnd();
 
    if (playHead.isUserDragging())
    {
        auto loopStart = playHead.getPlayoutSyncPosition();
        auto loopLen = playHead.getScrubbingBlockLength();
        auto loopEnd = loopStart + loopLen;
 
        s = PlayHead::linearPositionToLoopPosition (s, { loopStart, loopStart + loopLen });
        e = PlayHead::linearPositionToLoopPosition (e, { loopStart, loopStart + loopLen });
 
        if (s > e)
        {
            if (s >= loopEnd)
                return { { loopStart, e } };
 
            if (e <= loopStart)
                return { { s, loopEnd } };
 
            return { { s, loopEnd }, { loopStart, e } };
        }
    }
 
    if (playHead.isLooping() && ! playHead.isRollingIntoLoop())
    {
        const auto pr = playHead.getLoopRange();
        s = PlayHead::linearPositionToLoopPosition (s, pr);
        e = PlayHead::linearPositionToLoopPosition (e, pr);
 
        if (s > e)
        {
            if (s >= pr.getEnd())   return { { pr.getStart(), e } };
            if (e <= pr.getStart()) return { { s, pr.getEnd() } };
 
            return { { s, pr.getEnd() }, { pr.getStart(), e } };
        }
    }
 
    return { { s, e } };
}
 
}}