tracktion_Plugin.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 PluginCreationInfo
{
    PluginCreationInfo (const PluginCreationInfo&) = default;
    PluginCreationInfo (PluginCreationInfo&&) = default;
    PluginCreationInfo& operator= (PluginCreationInfo&&) = delete;
 
    PluginCreationInfo (Edit& ed, const juce::ValueTree& s, bool isNew) noexcept
        : edit (ed), state (s), isNewPlugin (isNew) {}
 
    PluginCreationInfo() = delete;
    PluginCreationInfo& operator= (const PluginCreationInfo&) = delete;
 
    Edit& edit;
    juce::ValueTree state;
    bool isNewPlugin = false;
};
 
//==============================================================================
struct PluginInitialisationInfo
{
    TimePosition startTime;
    double sampleRate;
    int blockSizeSamples;
};
 
//==============================================================================
//==============================================================================
struct PluginRenderContext
{
    PluginRenderContext (juce::AudioBuffer<float>* buffer,
                         const juce::AudioChannelSet& bufferChannels,
                         int bufferStart, int bufferSize,
                         MidiMessageArray* midiBuffer, double midiOffset,
                         TimeRange editTime, bool playing, bool scrubbing, bool rendering,
                         bool allowBypassedProcessing) noexcept;
 
    PluginRenderContext (const PluginRenderContext&) = default;
    PluginRenderContext (PluginRenderContext&&) = default;
 
    PluginRenderContext& operator= (const PluginRenderContext&) = delete;
    PluginRenderContext& operator= (PluginRenderContext&&) = delete;
 
    juce::AudioBuffer<float>* destBuffer = nullptr;
 
    juce::AudioChannelSet destBufferChannels;
 
    int bufferStartSample = 0;
 
    int bufferNumSamples = 0;
 
    MidiMessageArray* bufferForMidiMessages = nullptr;
 
    double midiBufferOffset = 0.0;
 
    TimeRange editTime;
 
    bool isPlaying = false;
 
    bool isScrubbing = false;
 
    bool isRendering = false;
 
    bool allowBypassedProcessing = false;
};
 
 
//==============================================================================
//==============================================================================
class Plugin  : public Selectable,
                public juce::ReferenceCountedObject,
                public Exportable,
                public AutomatableEditItem,
                public MacroParameterElement,
                protected ValueTreeAllEventListener
{
public:
    Plugin (PluginCreationInfo);
    ~Plugin() override;
 
    void selectableAboutToBeDeleted() override;
 
    //==============================================================================
    using Ptr      = juce::ReferenceCountedObjectPtr<Plugin>;
    using Array    = juce::ReferenceCountedArray<Plugin>;
 
    void playStartedOrStopped();
 
    virtual void initialiseFully();
 
    virtual void flushPluginStateToValueTree() override;
 
    //==============================================================================
    virtual juce::String getName() const override = 0;
    virtual juce::String getPluginType() = 0;
 
    virtual juce::String getVendor()                              { return "Tracktion"; }
    virtual juce::String getShortName (int /*suggestedLength*/)   { return getName(); }
 
    virtual juce::String getIdentifierString()                    { return getPluginType(); }
 
    virtual juce::String getTooltip();
 
    //==============================================================================
    virtual void setEnabled (bool);
    bool isEnabled() const noexcept                         { return enabled.get(); }
 
    void setFrozen (bool shouldBeFrozen);
    bool isFrozen() const noexcept                          { return frozen; }
 
    void setProcessingEnabled (bool p)                      { processing = p; }
    bool isProcessingEnabled() const noexcept               { return processing; }
 
    //==============================================================================
    virtual void initialise (const PluginInitialisationInfo&) = 0;
 
    virtual void initialiseWithoutStopping (const PluginInitialisationInfo&)  {}
 
    bool isInitialising() const             { return isInitialisingFlag; }
 
    virtual void deinitialise() = 0;
 
    virtual void reset();
 
    virtual void trackPropertiesChanged() {}
 
    //==============================================================================
    virtual void applyToBuffer (const PluginRenderContext&) = 0;
 
    virtual void prepareForNextBlock (TimePosition /*editTime*/) {}
 
    // wrapper on applyTobuffer, called by the node
    void applyToBufferWithAutomation (const PluginRenderContext&);
 
    virtual bool shoulMeasureCpuUsage() const noexcept  { return true; }
 
    double getCpuUsage() const noexcept     { return juce::jlimit (0.0, 1.0, timeToCpuScale * cpuUsageMs.load()); }
 
    //==============================================================================
    virtual int getNumOutputChannelsGivenInputs (int numInputChannels);
 
    virtual bool producesAudioWhenNoAudioInput()        { return isAutomationNeeded(); }
    virtual bool noTail()                               { return true; }
 
    virtual void getChannelNames (juce::StringArray* ins, juce::StringArray* outs);
    virtual bool takesAudioInput()                      { return ! isSynth(); }
    virtual bool takesMidiInput()                       { return false; }
    virtual bool isSynth()                              { return false; }
    virtual double getLatencySeconds()                  { return 0.0; }
    virtual double getTailLength() const                { return 0.0; }
    virtual bool canSidechain();
 
    juce::StringArray getInputChannelNames();
    juce::StringArray getSidechainSourceNames (bool allowNone);
    void setSidechainSourceByName (const juce::String& name);
    juce::String getSidechainSourceName();
    void guessSidechainRouting();
 
    //==============================================================================
    struct Wire
    {
        Wire (const juce::ValueTree&, juce::UndoManager*);
 
        juce::ValueTree state;
        juce::CachedValue<int> sourceChannelIndex, destChannelIndex;
    };
 
    //==============================================================================
    int getNumWires() const;
    Wire* getWire (int index) const;
 
    void makeConnection (int srcChannel, int dstChannel, juce::UndoManager*);
    void breakConnection (int srcChannel, int dstChannel);
 
    //==============================================================================
    virtual bool hasNameForMidiNoteNumber (int note, int midiChannel, juce::String& name);
 
    virtual bool hasNameForMidiProgram (int programNum, int bank, juce::String& name);
    virtual bool hasNameForMidiBank (int bank, juce::String& name);
 
    //==============================================================================
    virtual bool canBeAddedToClip()                                     { return true; }
    virtual bool canBeAddedToRack()                                     { return true; }
    virtual bool canBeAddedToFolderTrack()                              { return false; }
    virtual bool canBeAddedToMaster()                                   { return true; }
    virtual bool canBeDisabled()                                        { return true; }
    virtual bool canBeMoved()                                           { return true; }
    virtual bool needsConstantBufferSize() = 0;
 
    virtual bool isMissing()                                            { return false; }
 
    virtual bool isDisabled()                                           { return false; }
 
    bool isInRack() const;
    juce::ReferenceCountedObjectPtr<RackType> getOwnerRackType() const;
 
    bool isClipEffectPlugin() const;
 
    virtual juce::AudioProcessor* getWrappedAudioProcessor() const      { return {}; }
 
    //==============================================================================
    AutomatableParameter::Ptr getQuickControlParameter() const;
    void setQuickControlParameter (AutomatableParameter*);
 
    //==============================================================================
    virtual void deleteFromParent();
 
    void removeFromParent();
 
    //==============================================================================
    Track* getOwnerTrack() const;
 
    Clip* getOwnerClip() const;
 
    PluginList* getOwnerList() const;
 
    Ptr findPluginThatFeedsIntoThis() const;
    Ptr findPluginThatThisFeedsInto() const;
 
    void changed() override;
 
    //==============================================================================
    juce::Array<ReferencedItem> getReferencedItems() override;
    void reassignReferencedItem (const ReferencedItem&, ProjectItemID newID, double newStartTime) override;
 
    virtual void sourceMediaChanged()  {}
 
    //==============================================================================
    static bool areSelectedPluginsRackable (SelectionManager&);
    static RackInstance* wrapSelectedPluginsInRack (SelectionManager&);
    static void sortPlugins (Plugin::Array&);
    static void sortPlugins (std::vector<Plugin*>&);
 
    //==============================================================================
    // setting a master plugin whose settings will be mirrored
    bool setPluginToMirror (const Plugin::Ptr&); // fails if type is wrong
    virtual void updateFromMirroredPluginIfNeeded (Plugin&) {}
    Plugin::Ptr getMirroredPlugin() const;
 
    //==============================================================================
    enum class Type
    {
        allPlugins,
        folderTrackPlugins,
        effectPlugins,
    };
 
    //==============================================================================
    bool baseClassNeedsInitialising() const noexcept        { return initialiseCount == 0; }
    void baseClassInitialise (const PluginInitialisationInfo&);
    void baseClassDeinitialise();
 
    //==============================================================================
    void setSidechainSourceID (EditItemID newID)            { sidechainSourceID = newID; }
    EditItemID getSidechainSourceID() const                 { return sidechainSourceID; }
 
    //==============================================================================
    struct EditorComponent  : public juce::Component
    {
        virtual bool allowWindowResizing() = 0;
        virtual juce::ComponentBoundsConstrainer* getBoundsConstrainer() = 0;
    };
 
    virtual std::unique_ptr<EditorComponent> createEditor()     { return {}; }
 
    //==============================================================================
    struct WindowState  : public PluginWindowState
    {
        WindowState (Plugin&);
 
        Plugin& plugin;
 
    private:
        WindowState() = delete;
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WindowState)
    };
 
    std::unique_ptr<WindowState> windowState;
 
    void showWindowExplicitly();
    void hideWindowForShutdown();
 
    //==============================================================================
    Engine& engine;
    juce::ValueTree state;
 
    juce::UndoManager* getUndoManager() const noexcept;
 
protected:
    //==============================================================================
    juce::CachedValue<AtomicWrapper<bool>> enabled;
    juce::CachedValue<bool> frozen, processing;
    juce::CachedValue<juce::String> quickParamName;
    juce::CachedValue<EditItemID> masterPluginID, sidechainSourceID;
 
    double sampleRate = 44100.0;
    int blockSizeSamples = 512;
 
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeChanged() override;
 
    void valueTreeChildAdded (juce::ValueTree&, juce::ValueTree&) override;
    void valueTreeChildRemoved (juce::ValueTree&, juce::ValueTree&, int) override;
    void valueTreeParentChanged (juce::ValueTree&) override;
 
    virtual void processingChanged();
 
    //==============================================================================
    AutomatableParameter* addParam (const juce::String& paramID, const juce::String& name, juce::NormalisableRange<float> valueRange);
    AutomatableParameter* addParam (const juce::String& paramID, const juce::String& name, juce::NormalisableRange<float> valueRange,
                                    std::function<juce::String(float)> valueToStringFunction,
                                    std::function<float(const juce::String&)> stringToValueFunction);
 
    //==============================================================================
    static void getLeftRightChannelNames (juce::StringArray* ins, juce::StringArray* outs);
    static void getLeftRightChannelNames (juce::StringArray* chans);
 
private:
    mutable AutomatableParameter::Ptr quickControlParameter;
 
    std::atomic<int> initialiseCount { 0 };
    double timeToCpuScale = 0;
    std::atomic<double> cpuUsageMs { 0 };
    std::atomic<bool> isClipEffect { false };
 
    juce::ValueTree getConnectionsTree();
    struct WireList;
    std::unique_ptr<WireList> sidechainWireList;
    std::atomic<bool> isInitialisingFlag { false };
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Plugin)
};
 
}} // namespace tracktion { inline namespace engine