tracktion_CompManager.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 CompManager   : public juce::SingleThreadedReferenceCountedObject,
                      private juce::ValueTree::Listener
{
public:
    CompManager (Clip&, const juce::ValueTree&);
 
    ~CompManager() override;
 
    using Ptr = juce::ReferenceCountedObjectPtr<CompManager>;
 
    virtual void initialise();
 
    //==============================================================================
    virtual HashCode getBaseTakeHash (int takeIndex) const = 0;
    virtual double getTakeLength (int takeIndex) const = 0;
    virtual double getOffset() const = 0;
    virtual double getLoopLength() const = 0;
    virtual bool getAutoTempo() = 0;
    virtual double getSourceTempo() = 0;
    virtual juce::String getWarning()                   { return {}; }
    virtual float getRenderProgress() const             { return 1.0f; }
    virtual void discardCachedData()                    {}
 
    virtual void triggerCompRender() = 0;
 
    virtual void flattenTake (int takeIndex, bool deleteSourceFiles) = 0;
 
    virtual juce::ValueTree pasteComp (const juce::ValueTree& /*compTree*/) { return {}; }
 
    //==============================================================================
    Clip& getClip() const noexcept                      { return clip; }
 
    virtual void setStripToUpdate (juce::Component*)    {}
 
    bool shouldDisplayWarning() const noexcept          { return displayWarning; }
 
    //==============================================================================
    juce::ValueTree getSection (int takeIndex, int sectionIndex) const;
 
    juce::ValueTree findSectionAtTime (double time);
 
    int findSectionWithEndTime (juce::Range<double> range, int takeIndex, bool& timeFoundAtStartOfSection) const;
 
    juce::Range<double> getSectionTimes (const juce::ValueTree&) const;
 
    //==============================================================================
    juce::ValueTree getTakesTree()                      { return takesTree; }
 
    void setActiveTakeIndex (int index);
 
    int getActiveTakeIndex() const                      { return clip.getCurrentTake(); }
 
    juce::ValueTree getActiveTakeTree() const           { return takesTree.getChild (getActiveTakeIndex()); }
 
    int getNumTakes() const;
 
    int getNumComps() const                             { return takesTree.getNumChildren() - getNumTakes(); }
 
    int getTotalNumTakes() const                        { return takesTree.getNumChildren(); }
 
    bool isTakeComp (int takeIndex) const               { return isTakeComp (takesTree.getChild (takeIndex)); }
 
    bool isTakeComp (const juce::ValueTree& takeTree) const   { return bool (takeTree.getProperty (IDs::isComp, false)); }
 
    bool isCurrentTakeComp() const                      { return isTakeComp (getActiveTakeIndex()); }
 
    juce::String getTakeName (int index) const;
 
    //==============================================================================
    virtual juce::ValueTree addNewComp() = 0;
 
    double getMaxCompLength() const                 { return maxCompLength; }
 
    juce::Range<double> getCompRange() const;
 
    double getSpeedRatio() const;
 
    double getSourceTimeMultiplier() const          { return effectiveTimeMultiplier; }
 
    HashCode getTakeHash (int takeIndex) const;
 
    //==============================================================================
    void changeSectionIndexAtTime (double time, int takeIndex);
 
    void removeSectionIndexAtTime (double time, int takeIndex);
 
    void moveSectionEndTime (juce::ValueTree& section, double newTime);
 
    void moveSection (juce::ValueTree& section, double timeDelta);
 
    void moveSectionToEndAt (juce::ValueTree& section, double newEndTime);
 
    juce::ValueTree addSection (int takeIndex, double endTime);
 
    void removeSection (const juce::ValueTree& sectionToRemove);
 
    juce::ValueTree splitSectionAtTime (double time);
 
    void removeSectionsWithinRange (juce::Range<double> timeRange, const juce::ValueTree& sectionToKeep);
 
protected:
    juce::ValueTree takesTree;
    int lastRenderedTake = -1;
    HashCode lastHash = 0;
    double maxCompLength, effectiveTimeMultiplier;
    double lastOffset = 1.0, lastTimeRatio = 1.0;
 
    juce::UndoManager* getUndoManager() const;
    void keepSectionsSortedAndInRange();
    juce::ValueTree getNewCompTree() const;
 
private:
    //==============================================================================
    Clip& clip;
    bool displayWarning = false;
 
    //==============================================================================
    void reCacheInfo();
    void refreshCachedTakeLengths();
    void updateOffsetAndRatioFromSource();
    void addOrRemoveListenerIfNeeded();
 
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeChildAdded (juce::ValueTree& p, juce::ValueTree&) override        { if (p == takesTree) reCacheInfo(); }
    void valueTreeChildRemoved (juce::ValueTree& p, juce::ValueTree&, int) override { if (p == takesTree) reCacheInfo(); }
    void valueTreeChildOrderChanged (juce::ValueTree&, int, int) override           {}
    void valueTreeParentChanged (juce::ValueTree&) override                         {}
    void valueTreeRedirected (juce::ValueTree&) override                            { jassertfalse; }
 
    //==============================================================================
    struct RenderTrigger;
    std::unique_ptr<RenderTrigger> renderTrigger;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CompManager)
};
 
//==============================================================================
class CompFactory
{
public:
    CompFactory() = default;
    ~CompFactory() { jassert (comps.isEmpty()); }
 
    CompManager::Ptr getCompManager (Clip&);
 
private:
    friend class CompManager;
    juce::Array<CompManager*> comps;
    juce::CriticalSection compLock;
 
    void addComp (CompManager&);
    void removeComp (CompManager&);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CompFactory)
};
 
//==============================================================================
class WaveCompManager   : public CompManager,
                          private juce::Timer
{
public:
    using Ptr = juce::ReferenceCountedObjectPtr<WaveCompManager>;
 
    WaveCompManager (WaveAudioClip&);
    ~WaveCompManager() override;
 
    void updateThumbnails (juce::Component&, juce::OwnedArray<SmartThumbnail>& thumbnails) const;
 
    juce::File getCurrentCompFile() const;
 
    //==============================================================================
    HashCode getBaseTakeHash (int takeIndex) const override    { return getProjectItemIDForTake (takeIndex).getItemID(); }
    double getTakeLength (int takeIndex) const override;
    double getOffset() const override;
    double getLoopLength() const override;
    bool getAutoTempo() override;
    double getSourceTempo() override;
    juce::String getWarning() override;
    float getRenderProgress() const override;
 
    void triggerCompRender() override;
    void flattenTake (int takeIndex, bool deleteSourceFiles) override;
    juce::ValueTree pasteComp (const juce::ValueTree& compTree) override;
    void setStripToUpdate (juce::Component* strip) override;
 
    juce::ValueTree addNewComp() override;
 
    //==============================================================================
    struct CompRenderContext;
 
    CompRenderContext* createRenderContext() const;
 
    static bool renderTake (CompRenderContext&, AudioFileWriter&,
                            juce::ThreadPoolJob&, std::atomic<float>& progress);
 
private:
    enum { compGeneratorDelay = 500 };
 
    WaveAudioClip& clip;
    AudioFile lastCompFile;
    juce::String warning;
 
    //==============================================================================
    struct FlattenRetrier;
    std::unique_ptr<FlattenRetrier> flattenRetrier;
 
    struct CompUpdater;
    std::unique_ptr<CompUpdater> compUpdater;
 
    void setProjectItemIDForTake (int takeIndex, ProjectItemID) const;
    ProjectItemID getProjectItemIDForTake (int takeIndex) const;
    AudioFile getSourceFileForTake (int takeIndex) const;
    juce::File getDefaultTakeFile (int index) const;
    ProjectItem::Ptr getOrCreateProjectItemForTake (juce::ValueTree& takeTree);
 
    void timerCallback() override;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WaveCompManager)
};
 
//==============================================================================
class MidiCompManager   : public CompManager
{
public:
    using Ptr = juce::ReferenceCountedObjectPtr<MidiCompManager>;
 
    MidiCompManager (MidiClip&);
    ~MidiCompManager() override;
 
    void initialise() override;
    MidiList* getSequenceLooped (int index);
 
    //==============================================================================
    HashCode getBaseTakeHash (int takeIndex) const override;
    double getTakeLength (int takeIndex) const override;
    double getOffset() const override                       { return 0.0; }
    double getLoopLength() const override                   { return getTakeLength (0); }
    bool getAutoTempo() override                            { return false; }
    double getSourceTempo() override                        { return 1.0; }
    juce::String getWarning() override                      { return {}; }
    float getRenderProgress() const override                { return 1.0f; }
    void discardCachedData() override;
 
    void triggerCompRender() override;
    void flattenTake (int takeIndex, bool deleteSourceFiles) override;
    juce::ValueTree addNewComp() override;
 
private:
    MidiClip& clip;
    juce::ValueTree midiTakes;
    juce::OwnedArray<MidiList> cachedLoopSequences;
 
    void createComp (const juce::ValueTree& takeTree);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MidiCompManager)
};
 
}} // namespace tracktion { inline namespace engine