tracktion_Edit.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
{
 
class ClipEffect;
 
//==============================================================================
class Edit  : public Selectable,
              private juce::Timer
{
public:
    //==============================================================================
    enum EditRole
    {
        playDisabled        = 1,    
        proxiesDisabled     = 2,    
        pluginsDisabled     = 4,    
        forEditing          = 0,                                                    
        forRendering        = playDisabled,                                         
        forExporting        = playDisabled + proxiesDisabled + pluginsDisabled,     
        forExamining        = playDisabled + proxiesDisabled + pluginsDisabled      
    };
 
    struct LoadContext
    {
        std::atomic<float> progress  { 0.0f };  
        std::atomic<bool> completed  { false }; 
        std::atomic<bool> shouldExit { false }; 
    };
 
    //==============================================================================
    struct Options
    {
        Engine& engine;                                                         
        juce::ValueTree editState;                                              
        ProjectItemID editProjectItemID;                                        
 
        EditRole role = forEditing;                                             
        LoadContext* loadContext = nullptr;                                     
        int numUndoLevelsToStore = Edit::getDefaultNumUndoLevels();             
 
        std::function<juce::File()> editFileRetriever = {};                     
        std::function<juce::File (const juce::String&)> filePathResolver = {};  
 
        uint32_t numAudioTracks = 1;                                            
    };
 
    Edit (Options);
 
    Edit (Engine&, EditRole);
 
    ~Edit() override;
 
    Engine& engine;
 
    //==============================================================================
    juce::String getName();
 
    std::function<juce::File()> editFileRetriever;
 
    std::function<juce::File (const juce::String&)> filePathResolver;
 
    void setProjectItemID (ProjectItemID);
 
    ProjectItemID getProjectItemID() const noexcept    { return editProjectItemID; }
 
    //==============================================================================
    EditRole getEditRole() const noexcept   { return editRole; }
 
    bool shouldPlay() const noexcept        { return (editRole & playDisabled) == 0; }
 
    bool canRenderProxies() const noexcept  { return (editRole & proxiesDisabled) == 0; }
 
    bool shouldLoadPlugins() const noexcept { return (editRole & pluginsDisabled) == 0; }
 
    bool getIsPreviewEdit() const noexcept  { return isPreviewEdit; }
 
    //==============================================================================
    static constexpr double maximumLength = 48.0 * 60.0 * 60.0;
 
    static TimeDuration getMaximumLength()          { return TimeDuration::fromSeconds (maximumLength); }
 
    static TimeRange getMaximumEditTimeRange()      { return { TimePosition(), TimePosition::fromSeconds (maximumLength) }; }
 
    static TimePosition getMaximumEditEnd()         { return getMaximumEditTimeRange().getEnd(); }
 
    static const int ticksPerQuarterNote = 960; 
    //==============================================================================
    void flushState();
 
    void flushPluginStateIfNeeded (Plugin&);
 
    juce::Time getTimeOfLastChange() const;
 
    void resetChangedStatus();
 
    bool hasChangedSinceSaved() const;
 
    bool isLoading() const                                              { return isLoadInProgress; }
 
    //==============================================================================
    static std::unique_ptr<Edit> createEdit (Options);
 
    static std::unique_ptr<Edit> createEditForPreviewingFile (Engine&, const juce::File&, const Edit* editToMatch,
                                                              bool tryToMatchTempo, bool tryToMatchPitch, bool* couldMatchTempo,
                                                              juce::ValueTree midiPreviewPlugin,
                                                              juce::ValueTree midiDrumPreviewPlugin = {},
                                                              bool forceMidiToDrums = false,
                                                              std::unique_ptr<Edit> editToUpdate = {});
 
    static std::unique_ptr<Edit> createEditForPreviewingPreset (Engine& engine, juce::ValueTree, const Edit* editToMatch,
                                                                bool tryToMatchTempo, bool* couldMatchTempo,
                                                                juce::ValueTree midiPreviewPlugin,
                                                                juce::ValueTree midiDrumPreviewPlugin = {},
                                                                bool forceMidiToDrums = false,
                                                                std::unique_ptr<Edit> editToUpdate = {});
 
    static std::unique_ptr<Edit> createEditForPreviewingClip (Clip&);
 
    static std::unique_ptr<Edit> createSingleTrackEdit (Engine&, EditRole role = EditRole::forEditing);
 
    static std::unique_ptr<Edit> createEditForExamining (Engine&, juce::ValueTree, EditRole role = EditRole::forExamining);
 
    //==============================================================================
    EditItemCache<Track> trackCache;
 
    EditItemCache<ClipSlot> clipSlotCache;
 
    EditItemCache<Clip> clipCache;
 
    //==============================================================================
    EditInputDevices& getEditInputDevices() noexcept;
 
    InputDeviceInstance* getCurrentInstanceForInputDevice (InputDevice*) const;
 
    juce::Array<InputDeviceInstance*> getAllInputDevices() const;
 
    //==============================================================================
    TransportControl& getTransport() const noexcept                     { return *transportControl; }
 
    EditPlaybackContext* getCurrentPlaybackContext() const;
 
    //==============================================================================
    ParameterChangeHandler& getParameterChangeHandler() noexcept        { return *parameterChangeHandler; }
 
    ParameterControlMappings& getParameterControlMappings() noexcept    { return *parameterControlMappings; }
 
    AutomationRecordManager& getAutomationRecordManager() noexcept      { return *automationRecordManager; }
 
    AbletonLink& getAbletonLink() const noexcept;
 
    //==============================================================================
    struct ScopedRenderStatus
    {
        ScopedRenderStatus (Edit&, bool shouldReallocateOnDestruction);
 
        ~ScopedRenderStatus();
 
    private:
        Edit& edit;
        const bool reallocateOnDestruction;
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ScopedRenderStatus)
    };
 
    bool isRendering() const noexcept                           { return performingRenderCount.load() > 0; }
 
    //==============================================================================
    void initialiseAllPlugins();
 
    //==============================================================================
    juce::String getSelectableDescription() override            { return TRANS("Edit") + " - \"" + getName() + "\""; }
 
    //==============================================================================
    juce::UndoManager& getUndoManager() noexcept                { return undoManager; }
 
    void undo();
 
    void redo();
 
    struct UndoTransactionInhibitor
    {
        UndoTransactionInhibitor (Edit&);
 
        UndoTransactionInhibitor (const UndoTransactionInhibitor&);
 
        ~UndoTransactionInhibitor();
 
    private:
        SafeSelectable<Edit> edit;
    };
 
    static int getDefaultNumUndoLevels() noexcept               { return 30; }
 
    void restartPlayback();
 
    //==============================================================================
    TrackList& getTrackList()                                   { return *trackList; }
 
    void visitAllTracksRecursive (std::function<bool(Track&)>) const;
 
    void visitAllTopLevelTracks (std::function<bool(Track&)>) const;
 
    void visitAllTracks (std::function<bool(Track&)>, bool recursive) const;
 
    //==============================================================================
    juce::ReferenceCountedObjectPtr<AudioTrack> insertNewAudioTrack (TrackInsertPoint, SelectionManager*);
 
    juce::ReferenceCountedObjectPtr<FolderTrack> insertNewFolderTrack (TrackInsertPoint, SelectionManager*, bool asSubmix);
 
    juce::ReferenceCountedObjectPtr<AutomationTrack> insertNewAutomationTrack (TrackInsertPoint, SelectionManager*);
 
    Track::Ptr insertNewTrack (TrackInsertPoint, const juce::Identifier& xmlType, SelectionManager*);
 
    Track::Ptr insertTrack (TrackInsertPoint, juce::ValueTree, SelectionManager*);
 
    Track::Ptr insertTrack (juce::ValueTree, juce::ValueTree parent, juce::ValueTree preceeding, SelectionManager*);
 
    //==============================================================================
    void moveTrack (Track::Ptr, TrackInsertPoint);
 
    void copyTrack (Track::Ptr, TrackInsertPoint);
 
    void deleteTrack (Track*);
 
    void ensureNumberOfAudioTracks (int minimumNumTracks);
 
    void ensureArrangerTrack();
 
    void ensureTempoTrack();
 
    void ensureMarkerTrack();
 
    void ensureChordTrack();
 
    void ensureMasterTrack();
 
    ArrangerTrack* getArrangerTrack() const;
 
    MarkerTrack* getMarkerTrack() const;
 
    TempoTrack* getTempoTrack() const;
 
    ChordTrack* getChordTrack() const;
 
    MasterTrack* getMasterTrack() const;
 
    //==============================================================================
    bool areAnyTracksMuted() const;
 
    bool areAnyTracksSolo() const;
 
    bool areAnyTracksSoloIsolate() const;
 
    void updateMuteSoloStatuses();
 
    //==============================================================================
    LaunchQuantisation& getLaunchQuantisation();
 
    SceneList& getSceneList();
 
    //==============================================================================
    EditItemID createNewItemID() const;
 
    EditItemID createNewItemID (const std::vector<EditItemID>& idsToAvoid) const;
 
    //==============================================================================
    juce::Array<Clip*> findClipsInLinkGroup (juce::String linkGroupID) const;
 
    //==============================================================================
    void updateMirroredPlugin (Plugin&);
 
    void sendMirrorUpdateToAllPlugins (Plugin&) const;
 
    void sendStartStopMessageToPlugins();
 
    PluginList& getMasterPluginList() const noexcept            { return *masterPluginList; }
 
    //==============================================================================
    void addModifierTimer (ModifierTimer&);
 
    void removeModifierTimer (ModifierTimer&);
 
    void updateModifierTimers (TimePosition editTime, int numSamples) const;
 
    struct GlobalMacros : public MacroParameterElement
    {
        GlobalMacros (Edit&);
        Edit& edit;
    };
 
    MacroParameterElement& getGlobalMacros() const              { return *globalMacros; }
 
    //==============================================================================
    void setLowLatencyMonitoring (bool enabled, const juce::Array<EditItemID>& plugins);
 
    bool getLowLatencyMonitoring() const noexcept               { return lowLatencyMonitoring; }
 
    void setLowLatencyDisabledPlugins (const juce::Array<EditItemID>& plugins);
 
    juce::Array<EditItemID> getLowLatencyDisabledPlugins()      { return lowLatencyDisabledPlugins; }
 
    //==============================================================================
    RackTypeList& getRackList() const noexcept                  { jassert (rackTypes != nullptr); return *rackTypes; }
 
    TrackCompManager& getTrackCompManager() const noexcept      { jassert (trackCompManager != nullptr); return *trackCompManager; }
 
    //==============================================================================
    juce::String getAuxBusName (int bus) const;
 
    void setAuxBusName (int bus, const juce::String& name);
 
    //==============================================================================
    juce::Array<AutomatableParameter*> getAllAutomatableParams (bool includeTrackParams) const;
 
    void visitAllAutomatableParams (bool includeTrackParams, const std::function<void(AutomatableParameter&)>&) const;
 
    //==============================================================================
    juce::File getVideoFile() const;
 
    void setVideoFile (const juce::File&, juce::String importDesc);
 
    //==============================================================================
    TimePosition getNextTimeOfInterest (TimePosition afterThisTime);
 
    TimePosition getPreviousTimeOfInterest (TimePosition beforeThisTime);
 
    //==============================================================================
    PluginCache& getPluginCache() noexcept;
 
    TimePosition getFirstClipTime() const;
 
    TimeDuration getLength() const;
 
    //==============================================================================
    VolumeAndPanPlugin::Ptr getMasterVolumePlugin() const               { return masterVolumePlugin; }
 
    AutomatableParameter::Ptr getMasterSliderPosParameter() const       { jassert (masterVolumePlugin != nullptr); return masterVolumePlugin->volParam; }
 
    AutomatableParameter::Ptr getMasterPanParameter() const             { jassert (masterVolumePlugin != nullptr); return masterVolumePlugin->panParam; }
 
    void setMasterVolumeSliderPos (float);
 
    void setMasterPanPos (float);
 
    void pluginChanged (Plugin&) noexcept;
 
    //==============================================================================
    TempoSequence tempoSequence;
 
    TimecodeDisplayFormat getTimecodeFormat() const;
 
    void setTimecodeFormat (TimecodeDisplayFormat);
 
    void toggleTimecodeMode();
 
    void sendTempoOrPitchSequenceChangedUpdates();
 
    //==============================================================================
    PitchSequence pitchSequence;
 
    //==============================================================================
    std::shared_ptr<MidiInputDevice> getCurrentMidiTimecodeSource() const;
 
    void setCurrentMidiTimecodeSource (std::shared_ptr<MidiInputDevice>);
 
    void enableTimecodeSync (bool);
 
    bool isTimecodeSyncEnabled() const noexcept             { return midiTimecodeSourceDeviceEnabled; }
 
    TimeDuration getTimecodeOffset() const noexcept         { return timecodeOffset; }
 
    void setTimecodeOffset (TimeDuration newOffset);
 
    bool isMidiTimecodeIgnoringHours() const                { return midiTimecodeIgnoringHours; }
 
    void setMidiTimecodeIgnoringHours (bool shouldIgnore);
 
    std::shared_ptr<MidiInputDevice> getCurrentMidiMachineControlSource() const;
 
    void setCurrentMidiMachineControlSource (std::shared_ptr<MidiInputDevice>);
 
    MidiOutputDevice* getCurrentMidiMachineControlDest() const;
 
    void setCurrentMidiMachineControlDest (MidiOutputDevice*);
 
    void updateMidiTimecodeDevices();
 
    //==============================================================================
    void setClickTrackRange (TimeRange) noexcept;
 
    TimeRange getClickTrackRange() const noexcept;
 
    float getClickTrackVolume() const noexcept              { return juce::jlimit (0.2f, 1.0f, clickTrackGain.get()); }
 
    juce::String getClickTrackDevice() const;
 
    bool isClickTrackDevice (OutputDevice&) const;
 
    void setClickTrackOutput (const juce::String& deviceName);
 
    void setClickTrackVolume (float gain);
 
    //==============================================================================
    enum class CountIn
    {
        none      = 0,  
        oneBar    = 1,  
        twoBar    = 2,  
        twoBeat   = 3,  
        oneBeat   = 4   
    };
 
    void setCountInMode (CountIn);
 
    CountIn getCountInMode() const;
 
    int getNumCountInBeats() const;
 
    //==============================================================================
    void sendSourceFileUpdate();
 
    //==============================================================================
    void markAsChanged();
 
    void invalidateStoredLength() noexcept              { totalEditLength = {}; }
 
    void dispatchPendingUpdatesSynchronously();
 
    //==============================================================================
    bool areAnyClipsUsingFile (const AudioFile&);
 
    void cancelAllProxyGeneratorJobs() const;
 
    juce::File getTempDirectory (bool createIfNonExistent) const;
 
    void setTempDirectory (const juce::File&);
 
    //==============================================================================
    struct Metadata
    {
        juce::String artist, title, album, date, genre, comment, trackNumber;
    };
 
    Metadata getEditMetadata();
 
    void setEditMetadata (Metadata);
 
    //==============================================================================
    juce::ValueTree getAutomapState();
 
    //==============================================================================
    MarkerManager& getMarkerManager() const noexcept    { return *markerManager; }
 
    ARADocumentHolder& getARADocument();
 
    //==============================================================================
    template<typename OwnerType>
    struct LoadFinishedCallback   : public juce::Timer
    {
        LoadFinishedCallback (OwnerType& o, Edit& e) : owner (o), edit (e)
        {
            startTimer (10);
        }
 
        void timerCallback() override
        {
            if (! edit.isLoading())
            {
                stopTimer();
                owner.editFinishedLoading();
            }
        }
 
        OwnerType& owner;
        Edit& edit;
    };
 
    //==============================================================================
    struct WastedMidiMessagesListener
    {
        virtual ~WastedMidiMessagesListener() = default;
 
        virtual void warnOfWastedMidiMessages (InputDevice*, Track*) = 0;
    };
 
    void addWastedMidiMessagesListener (WastedMidiMessagesListener*);
 
    void removeWastedMidiMessagesListener (WastedMidiMessagesListener*);
 
    void warnOfWastedMidiMessages (InputDevice*, Track*);
 
    //==============================================================================
    SharedLevelMeasurer::Ptr getPreviewLevelMeasurer()          { return previewLevelMeasurer; }
 
    void setPreviewLevelMeasurer (SharedLevelMeasurer::Ptr p)   { previewLevelMeasurer = p; }
 
    //==============================================================================
    juce::CachedValue<juce::String> lastSignificantChange;  
 
    juce::CachedValue<TimeDuration> masterFadeIn,      
                                    masterFadeOut,     
                                    timecodeOffset,    
                                    videoOffset;       
 
    juce::CachedValue<AudioFadeCurve::Type> masterFadeInType,   
                                            masterFadeOutType;  
 
    juce::CachedValue<bool> midiTimecodeSourceDeviceEnabled,    
                            midiTimecodeIgnoringHours,          
                            videoMuted,                         
                            clickTrackEnabled,                  
                            clickTrackEmphasiseBars,            
                            clickTrackRecordingOnly,            
                            recordingPunchInOut,                
                            playInStopEnabled;                  
 
    juce::CachedValue<float> clickTrackGain;        
    juce::CachedValue<ProjectItemID> videoSource;   
 
    juce::ValueTree state { IDs::EDIT };     
    juce::ValueTree inputDeviceState;        
 
private:
    //==============================================================================
    const int instanceId;
    std::atomic<ProjectItemID> editProjectItemID { ProjectItemID() };
 
    // persistent properties (i.e. stuff that gets saved)
    juce::CachedValue<juce::String> clickTrackDevice;
    juce::CachedValue<juce::String> midiTimecodeSourceDevice, midiMachineControlSourceDevice, midiMachineControlDestDevice;
    juce::CachedValue<TimecodeDisplayFormat> timecodeFormat;
    juce::ValueTree auxBusses, controllerMappings, automapState;
    std::unique_ptr<ParameterControlMappings> parameterControlMappings;
    std::unique_ptr<RackTypeList> rackTypes;
    std::unique_ptr<PluginList> masterPluginList;
    std::unique_ptr<ARADocumentHolder> araDocumentHolder;
 
    // transient properties (i.e. stuff that doesn't get saved)
    struct MirroredPluginUpdateTimer;
    std::unique_ptr<MirroredPluginUpdateTimer> mirroredPluginUpdateTimer;
    juce::ReferenceCountedObjectPtr<VolumeAndPanPlugin> masterVolumePlugin;
    std::unique_ptr<TransportControl> transportControl;
    mutable std::unique_ptr<AbletonLink> abletonLink;
    std::unique_ptr<AutomationRecordManager> automationRecordManager;
    std::unique_ptr<MarkerManager> markerManager;
    struct UndoTransactionTimer;
    std::unique_ptr<UndoTransactionTimer> undoTransactionTimer;
    struct PluginChangeTimer;
    std::unique_ptr<PluginChangeTimer> pluginChangeTimer;
    struct FrozenTrackCallback;
    std::unique_ptr<FrozenTrackCallback> frozenTrackCallback;
    std::unique_ptr<ParameterChangeHandler> parameterChangeHandler;
    std::unique_ptr<PluginCache> pluginCache;
    std::unique_ptr<TrackCompManager> trackCompManager;
    juce::Array<ModifierTimer*, juce::CriticalSection> modifierTimers;
    std::unique_ptr<GlobalMacros> globalMacros;
 
    mutable std::optional<TimeDuration> totalEditLength;
    std::atomic<bool> isLoadInProgress { true };
    std::atomic<int> performingRenderCount { 0 };
    bool shouldRestartPlayback = false;
    bool blinkBright = false;
    bool lowLatencyMonitoring = false;
    bool hasChanged = false;
    bool ignoreLeftViewLimit;
    LoadContext* loadContext = nullptr;
    juce::UndoManager undoManager;
    int numUndoTransactionInhibitors = 0;
    mutable juce::File tempDirectory;
    juce::Array<EditItemID> lowLatencyDisabledPlugins;
    double normalLatencyBufferSizeSeconds = 0.0;
    bool isPreviewEdit = false;
    std::atomic<TimePosition> clickMark1Time { TimePosition() }, clickMark2Time { TimePosition() };
    std::atomic<bool> isFullyConstructed { false };
    mutable std::atomic<uint64_t> nextID { 0 }; // 0 is used as flag to initialise the next ID count
 
   #if JUCE_DEBUG
    mutable std::unordered_set<EditItemID> usedIDs;
   #endif
 
    const EditRole editRole;
 
    struct TreeWatcher;
    std::unique_ptr<TreeWatcher> treeWatcher;
 
    std::unique_ptr<TrackList> trackList;
    std::unique_ptr<EditInputDevices> editInputDevices;
    std::unique_ptr<SceneList> sceneList;
    std::unique_ptr<LaunchQuantisation> launchQuantisation;
 
 
    struct ChangedPluginsList;
    std::unique_ptr<ChangedPluginsList> changedPluginsList;
 
    struct EditChangeResetterTimer;
    std::unique_ptr<EditChangeResetterTimer> changeResetterTimer;
 
    SharedLevelMeasurer::Ptr previewLevelMeasurer;
    juce::ListenerList<WastedMidiMessagesListener> wastedMidiMessagesListeners;
 
    //==============================================================================
    friend struct TrackList;
 
    Track::Ptr createTrack (const juce::ValueTree&);
    Track::Ptr loadTrackFrom (juce::ValueTree&);
    void updateTrackStatuses();
    void updateTrackStatusesAsync();
    void moveTrackInternal (Track::Ptr, TrackInsertPoint);
 
    //==============================================================================
    void initialise (const Options&);
    void undoOrRedo (bool isUndo);
 
    //==============================================================================
    void initialiseTempoAndPitch();
    void initialiseTimecode (juce::ValueTree&);
    void initialiseTransport();
    void initialiseMasterVolume();
    void initialiseVideo();
    void initialiseClickTrack();
    void initialiseTracks (const Options&);
    void initialiseAudioDevices();
    void initialiseRacks();
    void initialiseMasterPlugins();
    void initialiseControllerMappings();
    void initialiseARA();
    void removeZeroLengthClips();
    void loadTracks();
    void loadOldTimeSigInfo();
    void loadOldVideoInfo (const juce::ValueTree&);
    void loadOldStyleMarkers();
 
    void timerCallback() override;
 
    void readFrozenTracksFiles();
    void updateFrozenTracks();
    void needToUpdateFrozenTracks();
 
    void sanityCheckTrackNames();
 
    // This constructor has been deprecated - use the other constructor that takes an Options,
    // or one of the static helper methods for creating an edit
    Edit (Engine&, juce::ValueTree, EditRole, LoadContext*, int numUndoLevelsToStore);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Edit)
};
 
//==============================================================================
struct EditDeleter  : private juce::AsyncUpdater
{
    ~EditDeleter() override;
 
    void deleteEdit (std::unique_ptr<Edit>);
 
private:
    friend class Engine;
    EditDeleter();
 
    juce::CriticalSection listLock;
    juce::OwnedArray<Edit> editsToDelete;
 
    void handleAsyncUpdate() override;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EditDeleter)
};
 
//==============================================================================
struct ActiveEdits
{
    juce::Array<Edit*> getEdits() const;
 
private:
    friend class Engine;
    friend class Edit;
    friend class TransportControl;
    juce::Array<Edit*, juce::CriticalSection> edits;
    std::atomic<int> numTransportsPlaying { 0 };
 
    ActiveEdits();
};
 
}} // namespace tracktion { inline namespace engine