GainNode /

Constructs a GainNode with an initial gain of 1 and optional format .

Constructs a GainNode with an initial gain of initialValue and optional format .

Sets the current value to a constant value .

Returns the current value.

Returns a pointer to the Param that can be used to animate the value.

Enables this Node for processing. Same as setEnabled( true ) .

Enables this Node for processing at when seconds, measured against Context::getNumProcessedSeconds() . Same as setEnabled( true, when ) .

Disables this Node for processing. Same as setEnabled( false ) .

Disables this Node for processing at when seconds, measured against Context::getNumProcessedSeconds() . Same as setEnabled( false, when ) .

Sets whether this Node is enabled for processing or not.

Sets whether this Node is enabled for processing or not at when seconds, measured against Context::getNumProcessedSeconds() .

Returns whether this Node is enabled for processing or not.

Connects this Node to output .

Disconnects this Node from output .

Disconnects this Node from all inputs and outputs.

Disconnects this Node from all outputs.

Disconnects all of this Node 's inputs.

Returns the number of inputs connected to this Node .

Returns the number of outputs this Node is connected to.

Returns true if input is connected to this Node as an input, false otherwise.

Returns true if output is connected to this Node as an output, false otherwise.

Returns the Context associated with this Node .

Cannot be called from within a Node 's constructor. Use initialize instead.

Returns the number of channels this Node will process.

Returns the channel mode.

ChannelMode .

Returns the maximum number of channels any input has.

Returns the samplerate of this Node , which is governed by the Context 's OutputNode .

Returns the number of frames processed in one block by this Node , which is governed by the Context 's OutputNode .

Returns whether this Node is automatically enabled / disabled when connected.

Sets whether this Node is automatically enabled / disabled when connected.

Returns whether this Node is in an initialized state and is capable of processing audio.

Returns whether this Node will process audio with an in-place Buffer .

Returns whether it is possible to connect to input , example reasons of failure would be this == Node , or Node is already an input.

Returns true if there is an unmanageable cycle betweeen sourceNode and destNode . If any Node 's in the traversal returns true for supportsCycles() , this method will return false.

Returns an immutable reference to the inputs container.

Returns a copy of the NodeRef's referenced by the this Node as outputs. The copy is necessary because outputs are stored internally with weak_ptr's.

Returns a string representing the name of this Node type. Default returns a demangled, compiler-specific class name.

Sets this Node 's name to a user-specified string.

Usually used internally by a Node subclass, returns a pointer to the internal buffer storage.

Usually used internally by a Node subclass, returns a pointer to the internal buffer storage.

Usually called internally by the Node , in special cases sub-classes may need to call this on other Node 's.

Override to perform audio processing on buffer. Default implementation is empty.

Called before audio buffers need to be used. There is always a valid Context at this point. Default implementation is empty.

Called once the contents of initialize are no longer relevant, i.e. connections have changed. Default implementation is empty.

Not guaranteed to be called at Node destruction.

Callled when this Node should enable processing. Initiated from Node::enable() . Default implementation is empty.

Callled when this Node should disable processing. Initiated from Node::disable() . Default implementation is empty.

Override to customize how input Nodes are summed into the internal summing buffer. You usually don't need to do this.

Default implementation returns true if numChannels matches our format.

Default implementation returns false, return true if it makes sense for the Node to be processed in a cycle (eg. Delay).

Default implementation returns true, subclasses should return false if they must process out-of-place (summing).

Connection methods be called on a non-audio thread and synchronized with the Context 's mutex.

Only Node subclasses can specify num channels directly - users specify via Format at construction time.

Only Node subclasses can specify channel mode directly - users specify via Format at construction time.

Returns a pair of frame indices for Nodes that wish to support sample accurate enable and disable.

The first index is where processing should start, the second is where it should end. Should only be called on the audio thread from within a Node 's process() method. Unless scheduled (with Context::schedule() ), this will be [0, getFramesPerBlock() ]