Class AudioNode

include/LabSound/core/AudioNode.h:83–249

AudioNode is the basic building block for a signal processing graph. It may be an audio source, an intermediate processing module, or an audio destination. Each AudioNode can have inputs and/or outputs. An AudioHardwareDeviceNode has one input and no outputs and represents the final destination to the audio hardware. Most processing nodes such as filters will have one input and one output,

// Most processing nodes such as filters will have one input and one output, 
//
class AudioNode
{
    static void _printGraph(const AudioNode * root, 
                        std::function<void(const char *)> prnln, int indent);

public :
    enum : int
    {
        ProcessingSizeInFrames = 128
    };

    int color = 0;

    AudioNode() = delete;
    virtual ~AudioNode();

    explicit AudioNode(AudioContext &, AudioNodeDescriptor const &);

    static void printGraph(const AudioNode* root, 
                        std::function<void(const char *)> prnln);

    //--------------------------------------------------
    // required interface
    //
    virtual const char* name() const = 0;

    // The input busses (if any) will already have their input data available
    // when process() is called. Subclasses will take this input data and 
    // render into this node's output buses.
    // Called from context's audio thread.
    virtual void process(ContextRenderLock &, int bufferSize) = 0;

    // Resets DSP processing state (clears delay lines, filter memory, etc.)
    // Called from context's audio thread.
    virtual void reset(ContextRenderLock &) = 0;

    // tailTime() is the length of time (not counting latency time) where 
    // non-zero output may occur after continuous silent input.
    virtual double tailTime(ContextRenderLock & r) const = 0;

    // latencyTime() is the length of time it takes for non-zero output to 
    // appear after non-zero input is provided. This only applies to processing
    // delay which is an artifact of the processing algorithm chosen and is 
    // *not* part of the intrinsic desired effect. For example, a "delay" 
    // effect is expected to delay the signal, and thus would not be considered
    // latency.
    virtual double latencyTime(ContextRenderLock & r) const = 0;

    //--------------------------------------------------
    // overridable interface
    //
    // If the final node class has ScheduledNode in its class hierarchy, this 
    // will return true. This is to save the cost of a dynamic_cast when
    // scheduling nodes.
    virtual bool isScheduledNode() const { return false; }

    // No significant resources should be allocated until initialize() is called.
    // Processing may not occur until a node is initialized.