tracktion_AudioNode.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.
*/
 
#pragma once
 
#include "tracktion_PlayHead.h"
#include "tracktion_EditTimeRange.h"
 
namespace tracktion { inline namespace engine
{
 
class AudioNode;
 
 
struct AudioNodeProperties
{
    bool hasAudio;
    bool hasMidi;
    int numberOfChannels;
};
 
//==============================================================================
struct PlaybackInitialisationInfo
{
    double startTime;
    double sampleRate;
    int blockSizeSamples;
    const juce::Array<AudioNode*>* rootNodes;
    PlayHead& playhead;
};
 
//==============================================================================
struct CreateAudioNodeParams
{
    const juce::Array<Clip*>* allowedClips = nullptr;
    const juce::BigInteger* allowedTracks = nullptr;
    AudioNode* audioNodeToBeReplaced = nullptr;
    bool forRendering = false;
    bool includePlugins = true;
    bool addAntiDenormalisationNoise = false;
};
 
//==============================================================================
struct AudioRenderContext
{
    //==============================================================================
    inline AudioRenderContext (PlayHead& ph, legacy::EditTimeRange stream,
                               juce::AudioBuffer<float>* buffer,
                               const juce::AudioChannelSet& bufferChannels,
                               int bufferStart, int bufferSize,
                               MidiMessageArray* midiBuffer, double midiOffset,
                               int continuityFlags, bool rendering) noexcept
        : playhead (ph), streamTime (stream),
          destBuffer (buffer), destBufferChannels (bufferChannels),
          bufferStartSample (bufferStart), bufferNumSamples (bufferSize),
          bufferForMidiMessages (midiBuffer), midiBufferOffset (midiOffset),
          continuity (continuityFlags), isRendering (rendering)
    {}
 
    AudioRenderContext (const AudioRenderContext&) = default;
    AudioRenderContext (AudioRenderContext&&) = default;
    AudioRenderContext& operator= (const AudioRenderContext&) = delete;
    AudioRenderContext& operator= (AudioRenderContext&&) = delete;
 
    //==============================================================================
    PlayHead& playhead;
 
    legacy::EditTimeRange streamTime;
 
    juce::AudioBuffer<float>* destBuffer;
 
    juce::AudioChannelSet destBufferChannels;
 
    int bufferStartSample;
 
    int bufferNumSamples;
 
    MidiMessageArray* bufferForMidiMessages;
 
    double midiBufferOffset;
 
    enum ContinuityFlags
    {
        contiguous           = 1,
        playheadJumped       = 2,
        lastBlockBeforeLoop  = 4,
        firstBlockOfLoop     = 8
    };
 
    int continuity;
 
    bool isContiguousWithPreviousBlock() const noexcept     { return (continuity & contiguous) != 0; }
    bool isFirstBlockOfLoop() const noexcept                { return (continuity & firstBlockOfLoop) != 0; }
    bool isLastBlockOfLoop() const noexcept                 { return (continuity & lastBlockBeforeLoop) != 0; }
    bool didPlayheadJump() const noexcept                   { return (continuity & playheadJumped) != 0; }
 
    bool isRendering;
 
    //==============================================================================
    PlayHead::EditTimeWindow getEditTime() const;
 
    void clearAudioBuffer() const noexcept;
    void clearMidiBuffer() const noexcept;
    void clearAll() const noexcept;
    void addAntiDenormalisationNoise() const noexcept;
 
    void sanityCheck() const
    {
        jassert (destBuffer == nullptr || bufferStartSample + bufferNumSamples <= destBuffer->getNumSamples());
    }
};
 
//==============================================================================
class AudioNode
{
public:
    //==============================================================================
    AudioNode();
    virtual ~AudioNode();
 
    //==============================================================================
    virtual void getAudioNodeProperties (AudioNodeProperties&) = 0;
 
    virtual void prepareAudioNodeToPlay (const PlaybackInitialisationInfo&) = 0;
 
    virtual bool purgeSubNodes (bool keepAudio, bool keepMidi) = 0;
 
    virtual void releaseAudioNodeResources() = 0;
 
    //==============================================================================
    using VisitorFn = std::function<void(AudioNode&)>;
    virtual void visitNodes (const VisitorFn&) = 0;
 
    virtual juce::ReferenceCountedObjectPtr<Plugin> getPlugin() const      { return {}; }
 
    // called before renderOver/Adding, to allow prefetching, etc
    virtual void prepareForNextBlock (const AudioRenderContext&)   {}
    virtual bool isReadyToRender() = 0;
 
    virtual void renderOver (const AudioRenderContext&) = 0;
    virtual void renderAdding (const AudioRenderContext&) = 0;
 
    void callRenderAdding (const AudioRenderContext&);
    void callRenderOver (const AudioRenderContext&);
 
    //==============================================================================
    template <typename CallbackType>
    static void invokeSplitRender (const AudioRenderContext& rc, CallbackType& target)
    {
        const PlayHead::EditTimeWindow editTime (rc.getEditTime());
 
        if (editTime.isSplit)
        {
            AudioRenderContext rc2 (rc);
 
            auto firstLen = editTime.editRange1.getLength();
            auto firstSamps = juce::jmin (rc.bufferNumSamples,
                                          (int) (firstLen * rc.bufferNumSamples / rc.streamTime.getLength()));
 
            rc2.streamTime = rc2.streamTime.withLength (firstLen);
            rc2.bufferNumSamples = firstSamps;
            rc2.continuity |= AudioRenderContext::lastBlockBeforeLoop;
 
            target.renderSection (rc2, editTime.editRange1);
 
            rc2.streamTime = { rc2.streamTime.getEnd(), rc.streamTime.getEnd() };
            rc2.bufferStartSample += firstSamps;
            rc2.bufferNumSamples = rc.bufferNumSamples - firstSamps;
            rc2.midiBufferOffset += firstLen;
            rc2.continuity = AudioRenderContext::firstBlockOfLoop;
 
            target.renderSection (rc2, editTime.editRange2);
        }
        else if (rc.playhead.isLooping() && ! rc.playhead.isRollingIntoLoop())
        {
            // In the case where looping happens to line up exactly with the audio
            // blocks being rendered, set the proper continuity flags
            AudioRenderContext rc2(rc);
 
            auto loop = rc.playhead.getLoopTimes();
 
            auto s = editTime.editRange1.getStart();
            auto e = editTime.editRange1.getEnd();
 
            if (e >= loop.getEnd() - 0.000001)
                rc2.continuity |= AudioRenderContext::lastBlockBeforeLoop;
            if (s <= loop.getStart() + 0.000001)
                rc2.continuity = AudioRenderContext::firstBlockOfLoop;
 
            target.renderSection (rc2, editTime.editRange1);
        }
        else
        {
            target.renderSection (rc, editTime.editRange1);
        }
    }
 
private:
    void callRenderOverForMidi (const AudioRenderContext&);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioNode)
};
 
//==============================================================================
class SingleInputAudioNode  : public AudioNode
{
public:
    SingleInputAudioNode (AudioNode* input);
 
    void getAudioNodeProperties (AudioNodeProperties&) override;
    void visitNodes (const VisitorFn&) override;
    void prepareAudioNodeToPlay (const PlaybackInitialisationInfo&) override;
    juce::ReferenceCountedObjectPtr<Plugin> getPlugin() const override;
    bool isReadyToRender() override;
    bool purgeSubNodes (bool keepAudio, bool keepMidi) override;
    void releaseAudioNodeResources() override;
    void prepareForNextBlock (const AudioRenderContext&) override;
    void renderOver (const AudioRenderContext&) override;
    void renderAdding (const AudioRenderContext&) override;
 
    const std::unique_ptr<AudioNode> input;
 
private:
    SingleInputAudioNode() = delete;
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SingleInputAudioNode)
};
 
//==============================================================================
struct MuteAudioNode  : public SingleInputAudioNode
{
    MuteAudioNode (AudioNode* source) : SingleInputAudioNode (source) {}
 
    void renderOver (const AudioRenderContext& rc) override
    {
        input->renderAdding (rc);
        rc.clearAll();
    }
 
    void renderAdding (const AudioRenderContext& rc) override
    {
        callRenderOver (rc);
    }
};
 
}} // namespace tracktion { inline namespace engine