tracktion_AudioClipBase.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 AudioClipBase    : public Clip,
                         public RenderManager::Job::Listener,
                         private juce::Timer
{
public:
    //==============================================================================
    AudioClipBase (const juce::ValueTree&, EditItemID, Type, ClipOwner&);
 
    ~AudioClipBase() override;
 
    using Ptr = juce::ReferenceCountedObjectPtr<AudioClipBase>;
 
    //==============================================================================
    TimeDuration getMaximumLength() override;
 
    virtual TimeDuration getSourceLength() const = 0;
 
    virtual AudioFile getAudioFile() const  { return AudioFile (edit.engine, getCurrentSourceFile()); }
 
    AudioFile getPlaybackFile();
 
    virtual juce::File getOriginalFile() const = 0;
 
    virtual HashCode getHash() const = 0;
 
    virtual AudioFileInfo getWaveInfo();
 
    //==============================================================================
    void markAsDirty();
 
    void updateSourceFile();
 
    virtual bool needsRender() const                    { return false; }
 
    virtual RenderManager::Job::Ptr getRenderJob (const AudioFile&)     { return {}; }
 
    virtual void renderComplete();
 
    virtual juce::String getRenderMessage()             { return {}; }
 
    virtual juce::String getClipMessage()               { return {}; }
 
    void cancelCurrentRender();
 
    //==============================================================================
    void setGainDB (float dB);
    float getGainDB() const noexcept                    { return level->dbGain.get(); }
    float getGain() const noexcept                      { return dbToGain (level->dbGain.get()); }
 
    void setPan (float pan);
    float getPan() const noexcept                       { return level->pan.get(); }
 
    void setMuted (bool shouldBeMuted) override         { level->mute = shouldBeMuted; }
    bool isMuted() const override                       { return level->mute.get(); }
 
    LiveClipLevel getLiveClipLevel();
 
    //==============================================================================
    void setLeftChannelActive (bool);
    bool isLeftChannelActive() const;
 
    void setRightChannelActive (bool);
    bool isRightChannelActive() const;
 
    juce::AudioChannelSet getActiveChannels() const     { return activeChannels; }
 
    //==============================================================================
    bool setFadeIn (TimeDuration length);
    TimeDuration getFadeIn() const;
 
    bool setFadeOut (TimeDuration length);
    TimeDuration getFadeOut() const;
 
    void setFadeInType (AudioFadeCurve::Type);
    AudioFadeCurve::Type getFadeInType() const          { return fadeInType; }
 
    void setFadeOutType (AudioFadeCurve::Type newType);
    AudioFadeCurve::Type getFadeOutType() const         { return fadeOutType; }
 
    void setAutoCrossfade (bool shouldAutoCrossfade)    { autoCrossfade = shouldAutoCrossfade; }
    bool getAutoCrossfade() const noexcept              { return autoCrossfade; }
 
    void updateAutoCrossfadesAsync (bool updateOverlapped);
    void applyEdgeFades();
 
    void copyFadeToAutomation (bool fadeIn, bool removeClipFade);
 
    //==============================================================================
    enum FadeBehaviour
    {
        gainFade = 0,   
        speedRamp       
    };
 
    void setFadeInBehaviour (FadeBehaviour newBehaviour)    { fadeInBehaviour = newBehaviour; }
    FadeBehaviour getFadeInBehaviour() const                { return fadeInBehaviour; }
 
    void setFadeOutBehaviour (FadeBehaviour newBehaviour)   { fadeOutBehaviour = newBehaviour; }
    FadeBehaviour getFadeOutBehaviour() const               { return fadeOutBehaviour; }
 
    //==============================================================================
    virtual void setLoopDefaults() = 0;
 
    void setLoopInfo (const LoopInfo&);
    const LoopInfo& getLoopInfo() const                 { return loopInfo; }
    LoopInfo& getLoopInfo()                             { return loopInfo; }
 
    TimeRange getLoopRange() const;
 
    bool canLoop() const override;
    bool isLooping() const override                     { return getAutoTempo() ? (loopLengthBeats > BeatDuration()) : (loopLength > TimeDuration()); }
    bool beatBasedLooping() const override              { return isLooping() && getAutoTempo(); }
    void setNumberOfLoops (int num) override;
    void disableLooping() override;
    BeatPosition getLoopStartBeats() const override;
    TimePosition getLoopStart() const override;
    BeatDuration getLoopLengthBeats() const override;
    TimeDuration getLoopLength() const override;
    void setLoopRange (TimeRange) override;
    void setLoopRangeBeats (BeatRange) override;
 
    void setAutoDetectBeats (bool);
    bool getAutoDetectBeats() const                     { return autoDetectBeats; }
 
    void setBeatSensitivity (float s);
    float getBeatSensitivity() const                    { return beatSensitivity; }
 
    void pitchTempoTrackChanged() override;
 
    //==============================================================================
    void setSpeedRatio (double newSpeed) override;
 
    void setTimeStretchMode (TimeStretcher::Mode mode);
 
    TimeStretcher::Mode getTimeStretchMode() const noexcept;
 
    TimeStretcher::Mode getActualTimeStretchMode() const noexcept;
 
    //==============================================================================
    enum AutoPitchMode
    {
        pitchTrack = 0, 
        chordTrackMono, 
        chordTrackPoly  
    };
 
    void setAutoTempo (bool shouldUseAutoTempo)         { autoTempo = shouldUseAutoTempo; }
 
    bool getAutoTempo() const                           { return autoTempo; }
 
    void setAutoPitch (bool shouldUseAutoPitch)         { autoPitch = shouldUseAutoPitch; }
 
    bool getAutoPitch() const                           { return autoPitch; }
 
    void setAutoPitchMode (AutoPitchMode m)             { autoPitchMode = m; }
 
    AutoPitchMode getAutoPitchMode()                    { return autoPitchMode; }
 
    void setWarpTime (bool shouldUseWarpTime)           { warpTime = shouldUseWarpTime; }
 
    bool getWarpTime() const                            { return warpTime; }
 
    WarpTimeManager& getWarpTimeManager() const;
 
    void setTranspose (int numSemitones)                { transpose = juce::jlimit (-24, 24, numSemitones); }
 
    int getTransposeSemiTones (bool includeAutoPitch) const;
 
    void setPitchChange (float semitones)               { pitchChange = juce::jlimit (-48.0f, 48.0f, semitones); }
 
    float getPitchChange() const                        { return pitchChange; }
 
    float getPitchRatio() const                         { return juce::jlimit (0.1f, 10.0f, std::pow (2.0f, pitchChange / 12.0f)); }
 
    void setIsReversed (bool shouldBeReversed)          { isReversed = shouldBeReversed; }
 
    bool getIsReversed() const noexcept                 { return isReversed; }
 
    LoopInfo autoDetectBeatMarkers (const LoopInfo& current, bool autoBeat, float sensitivity) const;
 
    bool performTempoDetect();
 
    static juce::StringArray getRootNoteChoices (Engine&);
 
    juce::StringArray getPitchChoices();
 
    //==============================================================================
    virtual bool canHaveEffects() const                 { return ! (warpTime || isReversed); }
 
    void enableEffects (bool enable, bool warn);
 
    bool effectsEnabled() const                         { return clipEffects != nullptr; }
 
    void addEffect (const juce::ValueTree& effectsTree);
 
    void setEffectsVisible (bool b)                     { clipEffectsVisible = b; }
 
    bool getEffectsVisible() const                      { return clipEffectsVisible; }
 
    ClipEffects* getClipEffects() const noexcept        { return clipEffects.get(); }
 
    //==============================================================================
    bool canSnapToOriginalBWavTime();
 
    void snapToOriginalBWavTime();
 
    //==============================================================================
    virtual juce::Array<ProjectItemID> getTakes() const;
 
    //==============================================================================
    juce::String canAddClipPlugin (const Plugin::Ptr&) const;
 
    //==============================================================================
    struct ProxyRenderingInfo
    {
        ProxyRenderingInfo();
        ~ProxyRenderingInfo();
 
        std::unique_ptr<AudioSegmentList> audioSegmentList;
        TimeRange clipTime;
        double speedRatio;
        TimeStretcher::Mode mode;
        TimeStretcher::ElastiqueProOptions options;
 
        bool render (Engine&, const AudioFile&, AudioFileWriter&, juce::ThreadPoolJob* const&, std::atomic<float>& progress) const;
 
    private:
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ProxyRenderingInfo)
    };
 
    virtual bool isUsingFile (const AudioFile&);
 
    AudioFile getProxyFileToCreate (bool renderTimestretched);
 
    void setUsesProxy (bool canUseProxy) noexcept;
 
    bool canUseProxy() const noexcept               { return proxyAllowed && edit.canRenderProxies(); }
 
    bool usesTimeStretchedProxy() const;
 
    std::unique_ptr<ProxyRenderingInfo> createProxyRenderingInfo();
 
    HashCode getProxyHash();
 
    void beginRenderingNewProxyIfNeeded();
 
    const AudioSegmentList& getAudioSegmentList();
 
    void setResamplingQuality (ResamplingQuality);
 
    ResamplingQuality getResamplingQuality() const;
 
    //==============================================================================
    void reverseLoopPoints();
 
    void checkFadeLengthsForOverrun();
 
    enum class ClipDirection { previous, next, none };
 
    AudioClipBase* getOverlappingClip (ClipDirection) const;
 
    //==============================================================================
    juce::ReferenceCountedObjectPtr<MelodyneFileReader> melodyneProxy;
 
    bool isUsingMelodyne() const;
 
    void showMelodyneWindow();
 
    void hideMelodyneWindow();
 
    void melodyneConvertToMIDI();
 
    void loadMelodyneState();
 
    bool setupARA (bool dontPopupErrorMessages);
 
    juce::CachedValue<TimeStretcher::ElastiqueProOptions> elastiqueProOptions;
 
    //==============================================================================
    void initialise() override;
    void cloneFrom (Clip*) override;
    void flushStateToValueTree() override;
 
    //==============================================================================
    void setParent (ClipOwner*) override;
    bool canBeAddedTo (ClipOwner&) override;
    void changed() override;
 
    //==============================================================================
    juce::Colour getDefaultColour() const override;
    PatternGenerator* getPatternGenerator() override;
 
    //==============================================================================
    void addMark (TimePosition relCursorPos);
    void moveMarkTo (TimePosition relCursorPos);
    void deleteMark (TimePosition relCursorPos);
    void getRescaledMarkPoints (juce::Array<TimePosition>& rescaled, juce::Array<int>& orig) const;
    juce::Array<TimePosition> getRescaledMarkPoints() const override;
 
    juce::Array<ReferencedItem> getReferencedItems() override;
    void reassignReferencedItem (const ReferencedItem&, ProjectItemID newID, double newStartTime) override;
 
    //==============================================================================
    std::shared_ptr<LaunchHandle> getLaunchHandle() override;
    void setUsesGlobalLaunchQuatisation (bool useGlobal) override           { useClipLaunchQuantisation = ! useGlobal; }
    bool usesGlobalLaunchQuatisation() override                             { return ! useClipLaunchQuantisation; }
    LaunchQuantisation* getLaunchQuantisation() override;
    FollowActions* getFollowActions() override;
 
    //==============================================================================
    bool addClipPlugin (const Plugin::Ptr&, SelectionManager&) override;
    Plugin::Array getAllPlugins() override;
    void sendMirrorUpdateToAllPlugins (Plugin&) const override;
    PluginList* getPluginList() override           { return &pluginList; }
 
protected:
    //==============================================================================
    friend class WaveCompManager;
 
    //==============================================================================
    std::shared_ptr<ClipLevel> level { std::make_shared<ClipLevel>() };
    juce::CachedValue<juce::String> channels;
 
    juce::CachedValue<TimeDuration> fadeIn, fadeOut;
    TimeDuration autoFadeIn, autoFadeOut;
    juce::CachedValue<AudioFadeCurve::Type> fadeInType, fadeOutType;
    juce::CachedValue<bool> autoCrossfade;
    juce::CachedValue<FadeBehaviour> fadeInBehaviour, fadeOutBehaviour;
    juce::CachedValue<ResamplingQuality> resamplingQuality;
 
    juce::CachedValue<TimePosition> loopStart;
    juce::CachedValue<TimeDuration> loopLength;
    juce::CachedValue<BeatPosition> loopStartBeats;
    juce::CachedValue<BeatDuration> loopLengthBeats;
 
    juce::CachedValue<int> proxyAllowed;
    juce::CachedValue<int> transpose;
    juce::CachedValue<float> pitchChange;
    LoopInfo loopInfo;
 
    juce::CachedValue<float> beatSensitivity;
    juce::CachedValue<TimeStretcher::Mode> timeStretchMode;
    juce::CachedValue<bool> autoPitch, autoTempo, isReversed, autoDetectBeats, warpTime, clipEffectsVisible;
    juce::CachedValue<AutoPitchMode> autoPitchMode;
 
    mutable WarpTimeManager::Ptr warpTimeManager;
    mutable std::unique_ptr<AudioSegmentList> audioSegmentList;
    std::unique_ptr<ClipEffects> clipEffects;
    mutable AsyncFunctionCaller asyncFunctionCaller;
 
    juce::AudioChannelSet activeChannels;
    void updateLeftRightChannelActivenessFlags();
 
    PluginList pluginList;
 
    bool lastRenderJobFailed = false;
 
    RenderManager::Job::Ptr renderJob;
    AudioFile lastProxy;
 
    //==============================================================================
    void createNewProxyAsync();
 
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeChildAdded (juce::ValueTree& parent, juce::ValueTree&) override;
    void valueTreeChildRemoved (juce::ValueTree& parent, juce::ValueTree&, int) override;
    void valueTreeChildOrderChanged (juce::ValueTree&, int, int) override;
    void valueTreeParentChanged (juce::ValueTree&) override;
 
private:
    //==============================================================================
    class TempoDetectTask;
    class BeatSensitivityComp;
 
    std::shared_ptr<LaunchHandle> launchHandle;
    juce::CachedValue<bool> useClipLaunchQuantisation;
    std::unique_ptr<LaunchQuantisation> launchQuantisation;
    std::unique_ptr<FollowActions> followActions;
 
    void updateReversedState();
    void updateAutoTempoState();
    void updateClipEffectsState();
 
    enum { updateCrossfadesFlag = 0, updateCrossfadesOverlappedFlag = 1 };
    void updateAutoCrossfades (bool updateOverlapped);
 
    void renderSource();
    bool shouldAttemptRender() const    { return (! lastRenderJobFailed) && needsRender(); }
 
    void clearCachedAudioSegmentList();
 
    //==============================================================================
    void jobFinished (RenderManager::Job& job, bool completedOk) override;
    void timerCallback() override;
 
    TimePosition clipTimeToSourceFileTime (TimePosition clipTime);
 
    //==============================================================================
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioClipBase)
};
 
}} // namespace tracktion { inline namespace engine
 
namespace juce
{
    template <>
    struct VariantConverter<tracktion::engine::AudioClipBase::FadeBehaviour>
    {
        static tracktion::engine::AudioClipBase::FadeBehaviour fromVar (const var& v)   { return (tracktion::engine::AudioClipBase::FadeBehaviour) static_cast<int> (v); }
        static var toVar (tracktion::engine::AudioClipBase::FadeBehaviour v)            { return static_cast<int> (v); }
    };
 
    template <>
    struct VariantConverter<tracktion::engine::AudioClipBase::AutoPitchMode>
    {
        static tracktion::engine::AudioClipBase::AutoPitchMode fromVar (const var& v)   { return (tracktion::engine::AudioClipBase::AutoPitchMode) static_cast<int> (v); }
        static var toVar (tracktion::engine::AudioClipBase::AutoPitchMode v)            { return static_cast<int> (v); }
    };
}