tracktion_Clip.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
{
 
//==============================================================================
struct ClipLevel
{
    juce::CachedValue<AtomicWrapper<float>> dbGain, pan;
    juce::CachedValue<AtomicWrapper<bool>> mute;
};
 
//==============================================================================
struct LiveClipLevel
{
    LiveClipLevel() noexcept = default;
 
    LiveClipLevel (std::shared_ptr<ClipLevel> l) noexcept
        : levels (std::move (l)) {}
 
    float getGain() const noexcept              { return levels ? dbToGain (levels->dbGain.get()) : 1.0f; }
 
    float getPan() const noexcept               { return levels ? static_cast<float> (levels->pan.get()) : 0.0f; }
 
    bool isMute() const noexcept                { return levels && levels->mute.get(); }
 
    float getGainIncludingMute() const noexcept { return isMute() ? 0.0f : getGain(); }
 
    void getLeftAndRightGains (float& left, float& right) const noexcept
    {
        const float g = getGainIncludingMute();
        const float pv = getPan() * g;
        left  = g - pv;
        right = g + pv;
    }
 
private:
    std::shared_ptr<ClipLevel> levels;
};
 
 
//==============================================================================
class Clip   : public TrackItem,
               public Exportable,
               protected juce::ValueTree::Listener
{
public:
    //==============================================================================
    Clip (const juce::ValueTree&, ClipOwner&, EditItemID, Type);
 
    ~Clip() override;
 
    virtual void initialise();
 
    using Ptr = juce::ReferenceCountedObjectPtr<Clip>;
    using Array = juce::ReferenceCountedArray<Clip>;
 
    //==============================================================================
    static bool isClipState (const juce::ValueTree&);
    static bool isClipState (const juce::Identifier&);
 
    static Ptr createClipForState (const juce::ValueTree&, ClipOwner& targetParent);
 
    virtual void flushStateToValueTree();
 
    virtual void sourceMediaChanged();
 
    virtual void pitchTempoTrackChanged() {}
 
    //==============================================================================
    virtual juce::String getName() const override       { return clipName; }
    void setName (const juce::String& newName);
 
    [[ nodiscard ]] virtual bool isMidi() const = 0;
 
    [[ nodiscard ]] virtual bool canBeAddedTo (ClipOwner&) = 0;
 
    //==============================================================================
    virtual bool usesSourceFile() const                 { return false; }
 
    SourceFileReference& getSourceFileReference()       { return sourceFileReference; }
 
    juce::File getCurrentSourceFile() const             { return currentSourceFile; }
 
    //==============================================================================
    juce::Array<ReferencedItem> getReferencedItems() override;
 
    void reassignReferencedItem (const ReferencedItem&, ProjectItemID /*newID*/, double /*newStartTime*/) override;
 
    //==============================================================================
    virtual std::shared_ptr<LaunchHandle> getLaunchHandle()     { return {}; }
 
    virtual void setUsesGlobalLaunchQuatisation (bool)          {}
 
    virtual bool usesGlobalLaunchQuatisation()                  { return true; }
 
    virtual LaunchQuantisation* getLaunchQuantisation()         { return {}; }
 
    virtual FollowActions* getFollowActions()                   { return {}; }
 
    enum class FollowActionDurationType
    {
        beats,  
        loops   
    };
 
    juce::CachedValue<FollowActionDurationType> followActionDurationType;
 
    juce::CachedValue<BeatDuration> followActionBeats;
 
    juce::CachedValue<double> followActionNumLoops;
 
    //==============================================================================
    ClipPosition getPosition() const override;
 
    BeatPosition getContentBeatAtTime (TimePosition) const;
    TimePosition getTimeOfContentBeat (BeatPosition) const;
 
    virtual TimeDuration getMaximumLength()               { return toDuration (Edit::getMaximumEditEnd()); }
 
    virtual juce::Array<TimePosition> getInterestingTimes();
 
    TimePosition getSpottingPoint() const;
 
    //==============================================================================
    virtual bool canLoop() const                    { return false; }
    virtual bool isLooping() const                  { return false; }
    virtual bool beatBasedLooping() const           { return false; }
    virtual void setNumberOfLoops (int)             {}
    virtual void disableLooping()                   {}
 
    virtual BeatPosition getLoopStartBeats() const          { return BeatPosition(); }
    virtual TimePosition getLoopStart() const               { return TimePosition(); }
    virtual BeatDuration getLoopLengthBeats() const         { return BeatDuration(); }
    virtual TimeDuration getLoopLength() const              { return TimeDuration(); }
 
    TimeRange getLoopRange() const                          { return { getLoopStart(), getLoopLength() }; }
    BeatRange getLoopRangeBeats() const                     { return { getLoopStartBeats(), getLoopLengthBeats() }; }
 
    virtual void setLoopRange (TimeRange)                   {}
    virtual void setLoopRangeBeats (BeatRange)              {}
 
    virtual bool isMuted() const = 0;
    virtual void setMuted (bool) {}
 
    enum SyncType
    {
        syncBarsBeats = 0,  
        syncAbsolute        
    };
 
    virtual void setSyncType (SyncType sync)        { syncType = sync; }
    SyncType getSyncType() const                    { return syncType; }
 
    //==============================================================================
    void setPosition (ClipPosition newPosition);
 
    void setStart (TimePosition newStart, bool preserveSync, bool keepLength);
 
    void setLength (TimeDuration newLength, bool preserveSync);
 
    void setEnd (TimePosition newEnd, bool preserveSync);
 
    void setOffset (TimeDuration newOffset);
 
    void trimAwayOverlap (TimeRange editRangeToTrim);
 
    void removeFromParent();
 
    bool moveTo (ClipOwner&);
 
    //==============================================================================
    double getSpeedRatio() const noexcept           { return speedRatio; }
 
    virtual void setSpeedRatio (double);
 
    virtual void rescale (TimePosition pivotTimeInEdit, double factor);
 
    //==============================================================================
    bool isGrouped() const override                 { return groupID.get().isValid(); }
    TrackItem* getGroupParent() const override;
    void setGroup (EditItemID newGroupID);
    EditItemID getGroupID() const noexcept          { return groupID; }
    CollectionClip* getGroupClip() const;
 
    //==============================================================================
    bool isLinked() const                           { return linkID.get().isNotEmpty(); }
    void setLinkGroupID (juce::String newLinkID)    { linkID = newLinkID; }
    juce::String getLinkGroupID() const             { return linkID; }
 
    //==============================================================================
    ClipOwner* getParent() const;
    ClipTrack* getClipTrack() const;
    Track* getTrack() const override;
    ClipSlot* getClipSlot() const;
 
    //==============================================================================
    virtual juce::Colour getColour() const;
    void setColour (juce::Colour col)               { colour = col; }
 
    //==============================================================================
    virtual void removePlugin (const Plugin::Ptr&)             {}
 
    virtual bool addClipPlugin (const Plugin::Ptr&, SelectionManager&)   { return false; }
 
    virtual Plugin::Array getAllPlugins()                      { return {}; }
    virtual void sendMirrorUpdateToAllPlugins (Plugin&) const  {}
 
    virtual PluginList* getPluginList()                        { return {}; }
 
    //==============================================================================
    virtual juce::Colour getDefaultColour() const = 0;
 
    //==============================================================================
    virtual void clearTakes()                               {}
    virtual bool hasAnyTakes() const                        { return false; }
    virtual juce::StringArray getTakeDescriptions() const   { return {}; }
    virtual void setCurrentTake (int /*takeIndex*/)         {}
    virtual int getCurrentTake() const                      { return 0; }
    virtual int getNumTakes (bool /*includeComps*/)         { return 0; }
    virtual bool isCurrentTakeComp()                        { return false; }
 
    virtual void setShowingTakes (bool shouldShow)          { showingTakes = shouldShow; }
    virtual bool isShowingTakes() const                     { return showingTakes;  }
 
    virtual Clip::Array unpackTakes (bool /*toNewTracks*/)  { return {}; }
 
    //==============================================================================
    virtual void cloneFrom (Clip*);
 
    void updateLinkedClips();
 
    //==============================================================================
    virtual PatternGenerator* getPatternGenerator() { return {}; }
 
    //==============================================================================
    struct Listener
    {
        /* Destructor */
        virtual ~Listener() = default;
 
        virtual void midiMessageGenerated (Clip&, const juce::MidiMessage&) = 0;
    };
 
    void addListener (Listener*);
 
    void removeListener (Listener*);
 
    juce::ListenerList<Listener>& getListeners()            { return listeners; }
 
    //==============================================================================
    void changed() override;
 
    juce::UndoManager* getUndoManager() const;
 
    juce::ValueTree state;                      
    juce::CachedValue<juce::Colour> colour;     
    juce::CachedValue<bool> disabled;           
    virtual void setParent (ClipOwner*);
 
protected:
    friend class Track;
    friend class ClipTrack;
    friend class CollectionClip;
 
    bool isInitialised = false;
    bool cloneInProgress = false;
    juce::CachedValue<juce::String> clipName;
    ClipOwner* parent = nullptr;
    juce::CachedValue<TimePosition> clipStart;
    juce::CachedValue<TimeDuration> length, offset;
    juce::CachedValue<double> speedRatio;
    SourceFileReference sourceFileReference;
    juce::CachedValue<EditItemID> groupID;
    juce::CachedValue<juce::String> linkID;
    juce::File currentSourceFile;
    juce::CachedValue<SyncType> syncType;
    juce::CachedValue<bool> showingTakes;
    std::unique_ptr<PatternGenerator> patternGenerator;
    AsyncCaller updateLinkedClipsCaller;
 
    juce::ListenerList<Listener> listeners;
 
    void setCurrentSourceFile (const juce::File&);
 
    virtual juce::Array<TimePosition> getRescaledMarkPoints() const;
 
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeParentChanged (juce::ValueTree&) override;
 
private:
    void updateParent();
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Clip)
};
 
 
//==============================================================================
namespace ClipConstants
{
    const double speedRatioMin = 0.01;  
    const double speedRatioMax = 20.0;  
}
 
namespace details
{
    Clip::FollowActionDurationType followActionDurationTypeFromString (juce::String);
    juce::String toString (Clip::FollowActionDurationType);
}
 
}} // namespace tracktion { inline namespace engine
 
namespace juce
{
    template<>
    struct VariantConverter<tracktion::engine::Clip::SyncType>
    {
        static tracktion::engine::Clip::SyncType fromVar (const var& v)   { return (tracktion::engine::Clip::SyncType) static_cast<int> (v); }
        static var toVar (tracktion::engine::Clip::SyncType v)            { return static_cast<int> (v); }
    };
 
    template<>
    struct VariantConverter<tracktion::engine::Clip::FollowActionDurationType>
    {
        static tracktion::engine::Clip::FollowActionDurationType fromVar (const var& v)
        {
            return tracktion::engine::details::followActionDurationTypeFromString (v);
        }
 
        static var toVar (tracktion::engine::Clip::FollowActionDurationType v)
        {
            return tracktion::engine::details::toString (v);
        }
    };
}