tracktion_TransportControl.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 namespace engine
{
 
void toStart (TransportControl&, const SelectableList&);
 
void toEnd (TransportControl&, const SelectableList&);
 
void tabBack (TransportControl&);
 
void tabForward (TransportControl&);
 
void markIn (TransportControl&);
 
void markOut (TransportControl&);
 
void scrub (TransportControl&, double unitsForwards);
 
void freePlaybackContextIfNotRecording (TransportControl&);
 
 
//==============================================================================
class TransportControl   : public juce::ChangeBroadcaster,
                           private juce::Timer
 
{
public:
    TransportControl (Edit&, const juce::ValueTree&);
    ~TransportControl() override;
 
    //==============================================================================
    void play (bool justSendMMCIfEnabled);
 
    void playFromStart (bool justSendMMCIfEnabled);
 
    void playSectionAndReset (TimeRange rangeToPlay);
 
    void record (bool justSendMMCIfEnabled, bool allowRecordingIfNoInputsArmed = false);
 
    void stop (bool discardRecordings,
               bool clearDevices,
               bool canSendMMCStop = true);
 
    void stopIfRecording();
 
    void stopRecording (bool discardRecordings = false);
 
    //==============================================================================
    juce::Result applyRetrospectiveRecord (bool armedOnly);
 
    juce::Array<juce::File> getRetrospectiveRecordAsAudioFiles();
 
    void syncToEdit (Edit* editToSyncTo, bool syncToTargetLoopLength);
 
    //==============================================================================
    bool isPlaying() const;
 
    bool isRecording() const;
 
    bool isSafeRecording() const;
 
    bool isStopping() const;
 
    bool isRecordingStopping() const;
 
    TimePosition getTimeWhenStarted() const;
 
    //==============================================================================
    TimePosition getPosition() const;
 
    void setPosition (TimePosition);
 
    void setPosition (TimePosition timeToMoveTo, TimePosition timeToPerformJump);
 
    void setUserDragging (bool);
 
    bool isUserDragging() const noexcept;
 
    bool isPositionUpdatingFromPlayhead() const;
 
    //==============================================================================
    void setLoopIn (TimePosition);
 
    void setLoopOut (TimePosition);
 
    void setLoopPoint1 (TimePosition);
 
    void setLoopPoint2 (TimePosition);
 
    void setLoopRange (TimeRange);
 
    TimeRange getLoopRange() const noexcept;
 
    void setSnapType (TimecodeSnapType);
 
    TimecodeSnapType getSnapType() const noexcept               { return currentSnapType; }
 
    //==============================================================================
    EditPlaybackContext* getCurrentPlaybackContext() const      { return playbackContext.get(); }
 
    bool isPlayContextActive() const                            { return playbackContext != nullptr; }
 
    void ensureContextAllocated (bool alwaysReallocate = false);
 
    void freePlaybackContext();
 
    void triggerClearDevicesOnStop();
 
    void forceOrphanFreezeAndProxyFilesPurge();
 
    //==============================================================================
    void setRewindButtonDown (bool isDown);
 
    void setFastForwardButtonDown (bool isDown);
 
    void nudgeLeft();
 
    void nudgeRight();
 
    //==============================================================================
    void editHasChanged();
 
    struct ReallocationInhibitor
    {
        ReallocationInhibitor (TransportControl&);
 
        ~ReallocationInhibitor();
 
    private:
        TransportControl& transport;
        JUCE_DECLARE_NON_COPYABLE (ReallocationInhibitor)
    };
 
    bool isAllowedToReallocate() const noexcept;
 
    //==============================================================================
    struct ScopedPlaybackRestarter
    {
        ScopedPlaybackRestarter (TransportControl& o) : tc (o), wasPlaying (tc.isPlaying()) {}
 
        ~ScopedPlaybackRestarter()   { if (wasPlaying) tc.play (false); }
 
        TransportControl& tc;
        bool wasPlaying = false;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ScopedPlaybackRestarter)
    };
 
    //==============================================================================
    struct ScopedContextAllocator
    {
        ScopedContextAllocator (TransportControl& o)
            : tc (o), wasAllocated (tc.isPlayContextActive())
        {}
 
        ~ScopedContextAllocator()
        {
            if (wasAllocated)
                tc.ensureContextAllocated();
        }
 
        TransportControl& tc;
        bool wasAllocated = false;
        ScopedPlaybackRestarter playbackRestarter { tc };
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ScopedContextAllocator)
    };
 
    //==============================================================================
    static juce::Array<TransportControl*> getAllActiveTransports (Engine&);
 
    static int getNumPlayingTransports (Engine&);
 
    static void stopAllTransports (Engine&, bool discardRecordings, bool clearDevices);
 
    static std::vector<std::unique_ptr<ScopedContextAllocator>> restartAllTransports (Engine&, bool clearDevices);
 
    //==============================================================================
    struct Listener
    {
        virtual ~Listener() {}
 
        virtual void playbackContextChanged() {}
 
        virtual void autoSaveNow() {}
 
        virtual void setAllLevelMetersActive (bool /*metersBecameInactive*/) {}
 
        virtual void setVideoPosition (TimePosition, bool /*forceJump*/) {}
 
        virtual void startVideo() {}
 
        virtual void stopVideo()  {}
 
        virtual void recordingStarted (SyncPoint /*start*/, std::optional<TimeRange> /*punchRange*/)  {}
 
        virtual void recordingStopped (SyncPoint, bool /*discardRecordings*/)  {}
 
        virtual void recordingAboutToStart (InputDeviceInstance&, EditItemID /*targetID*/) {}
 
        virtual void recordingAboutToStop (InputDeviceInstance&, EditItemID /*targetID*/) {}
 
        virtual void recordingFinished (InputDeviceInstance&,
                                        EditItemID /*targetID*/,
                                        const juce::ReferenceCountedArray<Clip>& /*recordedClips*/)
        {}
    };
 
    void addListener (Listener* l)          { listeners.add (l); }
 
    void removeListener (Listener* l)       { listeners.remove (l); }
 
    //==============================================================================
    Engine& engine;         
    Edit& edit;             
    juce::ValueTree state;  
    juce::CachedValue<TimePosition> startPosition; 
    juce::CachedValue<TimePosition> position;
    juce::CachedValue<TimePosition> loopPoint1, loopPoint2;
    juce::CachedValue<TimeDuration> scrubInterval;
    juce::CachedValue<bool> snapToTimecode, looping;
 
    //==============================================================================
    void callRecordingAboutToStartListeners (InputDeviceInstance&, EditItemID);
    void callRecordingAboutToStopListeners (InputDeviceInstance&, EditItemID);
    void callRecordingFinishedListeners (InputDeviceInstance&, EditItemID, juce::ReferenceCountedArray<Clip>);
 
private:
    //==============================================================================
    struct TransportState;
    std::unique_ptr<TransportState> transportState;
    std::unique_ptr<EditPlaybackContext> playbackContext;
    juce::ListenerList<Listener> listeners;
 
    TimecodeSnapType currentSnapType;
    bool isDelayedChangePending = false;
    int loopUpdateCounter = 10;
    bool isStopInProgress = false;
    bool recordingIsStoppingFlag = false;
 
    struct ScreenSaverDefeater;
    std::unique_ptr<ScreenSaverDefeater> screenSaverDefeater;
 
    struct PlayingFlag
    {
        PlayingFlag (Engine&) noexcept;
        ~PlayingFlag() noexcept;
 
        Engine& engine;
    };
 
    std::unique_ptr<PlayingFlag> playingFlag;
    void clearPlayingFlags();
 
    struct SectionPlayer;
    std::unique_ptr<SectionPlayer> sectionPlayer;
 
    struct PlayHeadWrapper;
    std::unique_ptr<PlayHeadWrapper> playHeadWrapper;
 
    bool lastPlayStatus = false, lastRecordStatus = false;
    void startedOrStopped();
    void releaseAudioNodes();
 
    void performPlay();
    std::optional<std::pair<SyncPoint, std::optional<TimeRange>>> performRecord();
    void performStop();
    std::optional<SyncPoint> performStopRecording();
 
    void performPositionChange();
    void performRewindButtonChanged();
    void performFastForwardButtonChanged();
    void performNudgeLeft();
    void performNudgeRight();
 
    void sendMMC (const juce::MidiMessage&);
    void sendMMCCommand (juce::MidiMessage::MidiMachineControlCommand);
    bool sendMMCStartPlay();
    bool sendMMCStartRecord();
 
    bool areAnyInputsRecording();
 
    struct FileFlushTimer;
    std::unique_ptr<FileFlushTimer> fileFlushTimer;
 
    struct ButtonRepeater;
    std::unique_ptr<ButtonRepeater> rwRepeater, ffRepeater;
 
    void timerCallback() override;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TransportControl)
};
 
}} // namespace tracktion { inline namespace engine