MonitorSpectralNode /

Returns the magnitude spectrum of the currently sampled audio stream, suitable for consuming on the main UI thread.

Returns the 'center of mass' of the magnitude spectrum, which is often correlated with the perception of 'brightness', in hertz.

The calculation of the magnitude spectrum happens on the main thread, so the result of getMagSpectrum() and getSpectralCentroid() might be analyzing different audio data that is streaming on the audio thread. For a more precise centroid of getMagSpectrum() , you can use audio::dsp::spectralCentroid() directly on it.

Returns the number of frequency bins in the analyzed magnitude spectrum. Equivalent to fftSize / 2.

Returns the size of the FFT used for spectral analysis.

Returns the corresponding frequency for bin . Computed as.

bin * getSampleRate() / getFftSize() 

Returns the factor (0 - 1, default = 0.5) used when smoothing the magnitude spectrum between sequential calls to getMagSpectrum() .

Sets the factor (0 - 1, default = 0.5) used when smoothing the magnitude spectrum between sequential calls to getMagSpectrum()

Returns a filled Buffer of the sampled audio stream, suitable for consuming on the main UI thread.

samples will only be copied if there is enough available in the internal dsp::RingBuffer .

Returns the window size, which is the number of samples that are copied from the audio stream. Equivalent to:

getBuffer().size() 

Compute the average (RMS) volume across all channels.

Compute the average (RMS) volume across channel .

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.

Copies audio frames from the RingBuffer into mCopiedBuffer, which is suitable for operation on the main thread.

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