tracktion_AudioTrack.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 AudioTrack  : public ClipTrack,
                    public MacroParameterElement,
                    private juce::Timer
{
public:
    AudioTrack (Edit&, const juce::ValueTree&);
    ~AudioTrack() override;
 
    using Ptr = juce::ReferenceCountedObjectPtr<AudioTrack>;
 
    void initialise() override;
    bool isAudioTrack() const override                      { return true; }
 
    //==============================================================================
    juce::String getSelectableDescription() override;
 
    //==============================================================================
    // This isn't an index - it starts from 1
    int getAudioTrackNumber() const noexcept;
 
    void sanityCheckName() override;
    juce::String getName() const override;
 
    juce::String getNameAsTrackNumber() const;
 
    juce::String getNameAsTrackNumberWithDescription() const;
 
    bool canContainPlugin (Plugin*) const override;
    bool processAudioNodesWhileMuted() const override       { return edit.engine.getEngineBehaviour().shouldProcessMutedTracks() || isSidechainSource(); }
 
    juce::CachedValue<AtomicWrapper<bool>> playSlotClips;
 
    //==============================================================================
    juce::String getTrackPlayabilityWarning() const;
    juce::String getLauncherPlayabilityWarning() const;
 
    //==============================================================================
    VolumeAndPanPlugin* getVolumePlugin();
    LevelMeterPlugin* getLevelMeterPlugin();
    EqualiserPlugin* getEqualiserPlugin();
    AuxSendPlugin* getAuxSendPlugin (int bus = -1, AuxPosition ap = AuxPosition::byBus) const; // -1 == any bus, first aux found
 
    //==============================================================================
    juce::String getNameForMidiNoteNumber (int note, int midiChannel, bool preferSharp = true) const;
 
    juce::String getNameForProgramNumber (int programNumber, int bank) const;
    juce::String getNameForBank (int bank) const;
    int getIdForBank (int bank) const;
    bool areMidiPatchesZeroBased() const;
 
    //==============================================================================
    WaveInputDevice& getWaveInputDevice() const noexcept        { jassert (waveInputDevice); return *waveInputDevice; }
    MidiInputDevice& getMidiInputDevice() const noexcept        { jassert (midiInputDevice); return *midiInputDevice; }
 
    TrackOutput& getOutput() const noexcept                     { return *output; }
 
    int getMaxNumOfInputs() const noexcept                      { return maxInputs; }
    void setMaxNumOfInputs (int newMaxNumber);
 
    bool canPlayAudio() const;
    bool canPlayMidi() const;
 
    //==============================================================================
    ClipSlotList& getClipSlotList();
 
    //==============================================================================
    bool isFrozen (FreezeType) const override;
    void setFrozen (bool, FreezeType) override;
    void insertFreezePointAfterPlugin (const Plugin::Ptr&);
    void removeFreezePoint();
    void freezeTrackAsync() const;
 
    //==============================================================================
    bool hasAnyLiveInputs();
    bool hasAnyTracksFeedingIn();
 
    juce::Array<Track*> getInputTracks() const override;
    juce::Array<Track*> findSidechainSourceTracks() const;
 
    void injectLiveMidiMessage (const MidiMessageArray::MidiMessageWithSource&);
    void injectLiveMidiMessage (const juce::MidiMessage&, MidiMessageArray::MPESourceID);
 
    //==============================================================================
    bool isMuted (bool includeMutingByDestination) const override;
    bool isSolo (bool includeIndirectSolo) const override;
    bool isSoloIsolate (bool includeIndirectSolo) const override;
 
    void setMute (bool) override;
    void setSolo (bool) override;
    void setSoloIsolate (bool) override;
 
    //==============================================================================
    double getMidiVisibleProportion() const;
    double getMidiVerticalOffset() const;
    void setMidiVerticalPos (double visibleProp, double offset);
    void scaleVerticallyToFitMidi();
    void setVerticalScaleToDefault();
 
    void setTrackToGhost (AudioTrack*, bool shouldGhost);
    void clearGhostTracks()                                         { ghostTracks.resetToDefault(); }
    juce::Array<AudioTrack*> getGhostTracks() const;
 
    int getCompGroup() const noexcept                               { return compGroup.get(); }
    void setCompGroup (int groupIndex)                              { compGroup = groupIndex; }
 
    //==============================================================================
    bool hasMidiNoteNames()                                         { return midiNoteMapCache.size() > 0; }
    void clearMidiNoteNames()                                       { midiNoteMap = juce::String(); }
    void loadMidiNoteNames (const juce::String namesFile)           { midiNoteMap = namesFile; }
 
    //==============================================================================
    bool mergeInMidiSequence (juce::MidiMessageSequence, TimePosition startTime,
                              MidiClip*, MidiList::NoteAutomationType);
 
    void playGuideNote (int note, MidiChannel midiChannel, int velocity,
                        bool stopOtherFirst = true, bool forceNote = false, bool autorelease = false);
 
    void playGuideNotes (const juce::Array<int>& notes, MidiChannel midiChannel,
                         const juce::Array<int>& velocities,
                         bool stopOthersFirst = true);
 
    void turnOffGuideNotes();
    void turnOffGuideNotes (MidiChannel);
 
    //==============================================================================
    struct FreezePointRemovalInhibitor
    {
        FreezePointRemovalInhibitor (AudioTrack&);
        ~FreezePointRemovalInhibitor();
        AudioTrack& track;
    };
 
    //==============================================================================
    struct Listener
    {
        /* Destructor */
        virtual ~Listener() = default;
 
        virtual void injectLiveMidiMessage (AudioTrack&, const MidiMessageArray::MidiMessageWithSource&, bool& wasUsed) = 0;
 
        virtual void recordedMidiMessageSentToPlugins (AudioTrack&, const juce::MidiMessage&) = 0;
    };
 
    void addListener (Listener*);
 
    void removeListener (Listener*);
 
    juce::ListenerList<Listener>& getListeners()            { return listeners; }
 
protected:
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeParentChanged (juce::ValueTree& v) override;
 
    bool isTrackAudible (bool areAnyTracksSolo) const override;
 
    void timerCallback() override   { turnOffGuideNotes(); }
 
private:
    //==============================================================================
    struct TrackMuter;
    struct FreezeUpdater;
    friend struct TrackMuter;
    friend class Edit;
    friend class Clip;
 
    //==============================================================================
    std::unique_ptr<TrackOutput> output;
    std::unique_ptr<WaveInputDevice> waveInputDevice;
    std::unique_ptr<MidiInputDevice> midiInputDevice;
 
    juce::CachedValue<bool> muted, soloed, soloIsolated;
    juce::CachedValue<bool> frozen, frozenIndividually;
 
    int freezePointRemovalInhibitor = 0;
    juce::CachedValue<int> maxInputs, compGroup;
 
    juce::CachedValue<juce::String> ghostTracks;
    juce::CachedValue<juce::String> midiNoteMap;
 
    std::map<int, juce::String> midiNoteMapCache;
 
    juce::Array<int> currentlyPlayingGuideNotes;
 
    std::unique_ptr<FreezeUpdater> freezeUpdater;
    std::unique_ptr<TrackMuter> trackMuter;
 
    enum { updateAutoCrossfadesFlag = 1 };
    AsyncFunctionCaller asyncCaller;
 
    juce::ListenerList<Listener> listeners;
    std::unique_ptr<ClipSlotList> clipSlotList;
 
    double defaultMidiVisibleProportion = 0, defaultMidiVerticalOffset = 0;
 
    //==============================================================================
    void freezeTrack();
    bool insertFreezePointIfRequired();
    int getIndexOfDefaultFreezePoint();
    int getIndexOfFreezePoint();
    void freezePlugins (juce::Range<int> pluginsToFreeze);
    void unFreezeTrack();
    juce::File getFreezeFile() const;
 
    void updateTracksToGhost();
    bool isSidechainSource() const;
 
    void updateMidiNoteMapCache();
 
    //==============================================================================
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioTrack)
};
 
}} // namespace tracktion { inline namespace engine