tracktion_WarpTimeManager.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 WarpMarker
{
    WarpMarker() noexcept = default;
 
    WarpMarker (TimePosition s, TimePosition w)
        : sourceTime (s), warpTime (w) {}
 
    WarpMarker (const juce::ValueTree& v)  : state (v)
    {
        updateFrom (v, IDs::sourceTime);
        updateFrom (v, IDs::warpTime);
    }
 
    void updateFrom (const juce::ValueTree& v, const juce::Identifier& i)
    {
        if (i == IDs::sourceTime)
            sourceTime = TimePosition::fromSeconds (double (v.getProperty (IDs::sourceTime)));
        else if (i == IDs::warpTime)
            warpTime = TimePosition::fromSeconds (double (v.getProperty (IDs::warpTime)));
    }
 
    HashCode getHash() const noexcept;
 
    juce::ValueTree state;
    TimePosition sourceTime, warpTime;
};
 
 
//==============================================================================
//==============================================================================
class WarpTimeManager : public juce::SingleThreadedReferenceCountedObject,
                        public RenderManager::Job::Listener
{
public:
    //==============================================================================
    using Ptr = juce::ReferenceCountedObjectPtr<WarpTimeManager>;
 
    WarpTimeManager (AudioClipBase&);
 
    WarpTimeManager (Edit&, const AudioFile& sourceFile, juce::ValueTree parentTree);
 
    ~WarpTimeManager() override;
 
    //==============================================================================
    void setSourceFile (const AudioFile&);
 
    AudioFile getSourceFile() const;
 
    TimeDuration getSourceLength() const;
 
    //==============================================================================
    bool isWarpEndMarkerEnabled() const noexcept                { return endMarkerEnabled; }
 
    bool areEndMarkersLimited() const noexcept                  { return endMarkersLimited; }
 
    const juce::Array<WarpMarker*>& getMarkers() const          { return markers->objects; }
 
    int insertMarker (WarpMarker);
 
    void removeMarker (int index);
 
    void removeAllMarkers();
 
    TimePosition moveMarker (int index, TimePosition newWarpTime);
 
    void setWarpEndMarkerTime (TimePosition endTime);
 
    //==============================================================================
    juce::Array<TimeRange> getWarpTimeRegions (TimeRange overallTimeRegion) const;
 
    std::pair<bool, juce::Array<TimePosition>> getTransientTimes() const    { return transientTimes; }
 
    TimePosition warpTimeToSourceTime (TimePosition warpTime) const;
 
    TimePosition sourceTimeToWarpTime (TimePosition sourceTime) const;
 
    TimePosition getWarpedStart() const;
 
    TimePosition getWarpedEnd() const;
 
    TimePosition getWarpEndMarkerTime() const;
 
    HashCode getHash() const;
 
    void editFinishedLoading();
 
    Edit& edit;
    juce::ValueTree state;
 
private:
    struct WarpMarkerList   : public ValueTreeObjectList<WarpMarker>
    {
        WarpMarkerList (const juce::ValueTree& v)
            : ValueTreeObjectList<WarpMarker> (v), state (v)
        {
            rebuildObjects();
        }
 
        ~WarpMarkerList() override
        {
            freeObjects();
        }
 
        bool isSuitableType (const juce::ValueTree& v) const override   { return v.hasType (IDs::WARPMARKER); }
        WarpMarker* createNewObject (const juce::ValueTree& v) override { return new WarpMarker (v); }
        void deleteObject (WarpMarker* wm) override                     { delete wm; }
        void newObjectAdded (WarpMarker*) override                      {}
        void objectRemoved (WarpMarker*) override                       {}
        void objectOrderChanged() override                              {}
 
        void valueTreePropertyChanged (juce::ValueTree& v, const juce::Identifier& i) override
        {
            if (v.hasType (IDs::WARPMARKER))
                if (auto wm = getWarpMarkerFor (v))
                    wm->updateFrom (v, i);
        }
 
        juce::ValueTree state;
 
    private:
        WarpMarker* getWarpMarkerFor (const juce::ValueTree& v)
        {
            jassert (v.hasType (IDs::WARPMARKER));
            return objects[v.getParent().indexOf (v)];
        }
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WarpMarkerList)
    };
 
    friend class WarpTimeFactory;
 
    const AudioClipBase* clip = nullptr;
    AudioFile sourceFile;
    bool endMarkerEnabled = true, endMarkersLimited = false;
 
    std::unique_ptr<WarpMarkerList> markers;
    RenderManager::Job::Ptr transientDetectionJob;
    std::pair<bool, juce::Array<TimePosition>> transientTimes { false, {} };
    std::unique_ptr<Edit::LoadFinishedCallback<WarpTimeManager>> editLoadedCallback;
 
    juce::UndoManager* getUndoManager() const;
    void jobFinished (RenderManager::Job& job, bool completedOk) override;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WarpTimeManager)
};
 
 
//==============================================================================
//==============================================================================
class WarpTimeFactory
{
public:
    WarpTimeFactory() = default;
 
    ~WarpTimeFactory()  { jassert (warpTimeManagers.isEmpty()); }
 
    WarpTimeManager::Ptr getWarpTimeManager (const Clip&);
 
private:
    friend class WarpTimeManager;
    juce::Array<WarpTimeManager*> warpTimeManagers;
    juce::CriticalSection warpTimeLock;
 
    void addWarpTimeManager (WarpTimeManager&);
    void removeWarpTimeManager (WarpTimeManager&);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WarpTimeFactory)
};
 
}} // namespace tracktion { inline namespace engine