BufferRecorderNode /

Constructs a BufferRecordNode and initializes its buffer to be large enough to hold numFrames frames.

Starts recording. Resets the write position to zero (call disable() to pause recording).

Stops recording. Same as calling disable() .

Sets the length of the recording buffer in frames.

If the write position is non-zero, the old contents will be preserved (by copying it to the newly allocated Buffer ). If shrinkToFit is set to true , the internal Buffer will be down-sized if necessary, otherwise it will only re-allocate when growing while changing its dimensions to match numFrames (default shrinkToFit = false).

Sets the length of the recording buffer in seconds.

setNumFrames

Returns the length of the recording buffer in frames.

Returns the length of the recording buffer in seconds.

Returns a copy of the recored samples, up to the current write position.

This method is non locking, and as such any resizing calls must be performed on the same thread or be otherwise synchronized.

Writes the currently recorded samples to a file at filePath .

The encoding format is derived from filePath's extension and sampleType (default = SampleType::INT_16 ).

throws AudioFileExc if the write request cannot be completed.

Returns the frame of the last buffer overrun or 0 if none since the last time this method was called. When this happens, it means the recorded buffer probably has skipped some frames.

Returns the current write position, which represents how many samples are currently recorded.

Connects this Node to output .

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

Overridden to remove from Context 's auto-pulled list if there are no more outputs.

Overridden to also remove from Context 's auto-pulled list.

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.

Disconnects this Node from output .

Disconnects this Node from all inputs and 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.

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

Override to perform audio processing on buffer. 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).

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() ]