vital::StereoEncoder Class Reference

Encodes or decodes a stereo signal by rotating or centering the phase of the left and right channels. More...

#include <operators.h>

Inheritance diagram for vital::StereoEncoder:

Public Types
enum	{ kAudio , kEncodingValue , kMode , kNumInputs }
enum	{ kSpread , kRotate , kNumStereoModes }

Public Member Functions
	StereoEncoder (bool decoding=false)
	Constructs a StereoEncoder. If decoding is true, the math is adjusted for decoding instead of encoding.
virtual Processor *	clone () const override
	Clones this Processor for polyphonic expansion. Must be overridden by subclasses.
void	process (int num_samples) override
	Processes the stereo input, either applying rotation or a center/spread mix.
bool	hasState () const override
	Indicates that this operator has internal state (cos/sin multipliers) that may change over time.
Public Member Functions inherited from vital::Operator
	Operator (int num_inputs, int num_outputs, bool control_rate=false)
	Constructs an Operator with a specified number of inputs/outputs and control-rate setting.
force_inline bool	hasEnoughInputs ()
	Checks if this Operator has at least one connected input.
void	setEnabled ()
	Updates this operator’s enabled state based on connected inputs and external status.
void	numInputsChanged () override
	Called when the number of inputs changes (e.g., dynamically connected or disconnected).
void	enable (bool enable) override
	Enables or disables the Operator, storing the external enable state.
Public Member Functions inherited from vital::Processor
	Processor (int num_inputs, int num_outputs, bool control_rate=false, int max_oversample=1)
	Constructs a Processor with a given number of inputs/outputs and oversampling.
virtual	~Processor ()
	Virtual destructor.
virtual void	processWithInput (const poly_float *audio_in, int num_samples)
	An optional processing function taking explicit input buffer. Fallback is an assertion failure (not supported).
virtual void	init ()
	Called after constructor, used for any additional initialization. Subclasses can override. Sets the initialized flag.
virtual void	reset (poly_mask reset_mask)
	Called to reset the Processor's per-voice state (e.g., on note-on).
virtual void	hardReset ()
	Called to perform a "hard" reset for all voices.
bool	initialized ()
	Returns whether this Processor has been initialized.
virtual void	setSampleRate (int sample_rate)
	Updates the sample rate of this Processor (scaled by oversampling).
virtual void	setOversampleAmount (int oversample)
	Sets the oversampling amount and updates the effective sample rate.
force_inline bool	enabled () const
	Checks if this Processor is enabled.
force_inline int	getSampleRate () const
	Retrieves the current (effective) sample rate.
force_inline int	getOversampleAmount () const
	Retrieves the current oversampling factor.
force_inline bool	isControlRate () const
	Checks if this Processor is running at control rate (buffer_size == 1).
virtual void	setControlRate (bool control_rate)
	Sets whether this Processor runs at control rate.
force_inline poly_mask	getResetMask (int input_index) const
	Retrieves a mask indicating which voices triggered a note-on event. Compares the input's trigger_value to kVoiceOn.
force_inline void	clearOutputBufferForReset (poly_mask reset_mask, int input_index, int output_index) const
	Clears output samples for voices that are about to be reset, based on the trigger offset.
bool	inputMatchesBufferSize (int input=0)
	Checks whether the buffer size of a particular input matches the size needed by this Processor.
bool	checkInputAndOutputSize (int num_samples)
	Checks if all inputs and outputs have buffers big enough for num_samples.
virtual bool	isPolyphonic () const
	Checks if this Processor is polyphonic by querying its ProcessorRouter.
void	plug (const Output *source)
	Connects an external Output to this Processor's first input.
void	plug (const Output *source, unsigned int input_index)
	Connects an external Output to a specified input index.
void	plug (const Processor *source)
	Connects the first output of a Processor to this Processor's first input.
void	plug (const Processor *source, unsigned int input_index)
	Connects the first output of a Processor to a specified input index.
void	plugNext (const Output *source)
	Connects an external Output to the first available (unplugged) input.
void	plugNext (const Processor *source)
	Connects the first output of a Processor to the first available (unplugged) input.
void	useInput (Input *input)
	Uses an existing Input object as this Processor's first input.
void	useInput (Input *input, int index)
	Uses an existing Input object at a specified input index.
void	useOutput (Output *output)
	Uses an existing Output object as this Processor's first output.
void	useOutput (Output *output, int index)
	Uses an existing Output object at a specified output index.
int	connectedInputs ()
	Counts how many inputs are connected to a real source (not null_source_).
virtual void	unplugIndex (unsigned int input_index)
	Removes the connection at a specified input index, if any.
virtual void	unplug (const Output *source)
	Removes a connection to a given Output from all inputs.
virtual void	unplug (const Processor *source)
	Removes connections to all outputs from a given Processor.
force_inline void	router (ProcessorRouter *router)
	Sets the ProcessorRouter that owns or manages this Processor.
force_inline ProcessorRouter *	router () const
	Returns the ProcessorRouter that currently owns this Processor.
ProcessorRouter *	getTopLevelRouter () const
	Gets the topmost (root) ProcessorRouter by traversing parent routers.
virtual void	registerInput (Input *input, int index)
	Registers a new input, appending it to the input list.
virtual Output *	registerOutput (Output *output, int index)
	Registers a new Output in the output list at a specified index.
virtual void	registerInput (Input *input)
	Registers a new Input by appending it to the end of the input list.
virtual Output *	registerOutput (Output *output)
	Registers a new Output by appending it to the end of the output list.
force_inline int	numInputs () const
	Returns the total number of Input pointers (owned or otherwise).
force_inline int	numOutputs () const
	Returns the total number of Output pointers (owned or otherwise).
force_inline int	numOwnedInputs () const
	Returns how many Input objects this Processor owns.
force_inline int	numOwnedOutputs () const
	Returns how many Output objects this Processor owns.
force_inline Input *	input (unsigned int index=0) const
	Retrieves the Input pointer at a given index.
force_inline bool	isInputSourcePolyphonic (int index=0)
	Checks if the input source at a given index is polyphonic.
force_inline Input *	ownedInput (unsigned int index=0) const
	Retrieves an owned Input pointer at a given index.
force_inline Output *	output (unsigned int index=0) const
	Retrieves the Output pointer at a given index.
force_inline Output *	ownedOutput (unsigned int index=0) const
	Retrieves an owned Output pointer at a given index.
void	setPluggingStart (int start)
	Sets the position at which plugNext starts searching for an open input.

Protected Member Functions
void	processRotate (int num_samples)
	Processes the stereo signal in rotate mode (phase rotation).
void	processCenter (int num_samples)
	Processes the stereo signal in spread/center mode.
Protected Member Functions inherited from vital::Processor
Output *	addOutput (int oversample=1)
	Creates and registers a new Output. Handles control rate vs. audio rate.
Input *	addInput ()
	Creates and registers a new Input, initially connected to null_source_.

Protected Attributes
poly_float	cos_mult_
poly_float	sin_mult_
mono_float	decoding_mult_
Protected Attributes inherited from vital::Processor
std::shared_ptr< ProcessorState >	state_
	Shared state (sample rate, oversample, etc.)
int	plugging_start_
	The index at which plugNext starts searching for an unplugged input.
std::vector< std::shared_ptr< Input > >	owned_inputs_
	Inputs owned by this Processor.
std::vector< std::shared_ptr< Output > >	owned_outputs_
	Outputs owned by this Processor.
std::shared_ptr< std::vector< Input * > >	inputs_
	All inputs, owned or external.
std::shared_ptr< std::vector< Output * > >	outputs_
	All outputs, owned or external.
ProcessorRouter *	router_
	The ProcessorRouter that manages this Processor.

Additional Inherited Members
Static Protected Attributes inherited from vital::Processor
static const Output	null_source_
	A null (dummy) source used for unconnected inputs.

Detailed Description

Encodes or decodes a stereo signal by rotating or centering the phase of the left and right channels.

The mode (spread vs. rotate) and the encoding value are used to compute rotation or mix between channels.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
kAudio
kEncodingValue
kMode
kNumInputs

anonymous enum

anonymous enum

Enumerator
kSpread
kRotate
kNumStereoModes

Constructor & Destructor Documentation

StereoEncoder()

vital::StereoEncoder::StereoEncoder ( bool decoding = false )

inline

Constructs a StereoEncoder. If decoding is true, the math is adjusted for decoding instead of encoding.

Parameters

decoding

Set to true for decoding, false for standard encoding.

Member Function Documentation

clone()

virtual Processor * vital::StereoEncoder::clone ( ) const

inlineoverridevirtual

Clones this Processor for polyphonic expansion. Must be overridden by subclasses.

Returns

A pointer to a newly allocated Processor that is a copy of this Processor.

Implements vital::Processor.

hasState()

bool vital::StereoEncoder::hasState ( ) const

inlineoverridevirtual

Indicates that this operator has internal state (cos/sin multipliers) that may change over time.

Returns

True for stateful operators.

Reimplemented from vital::Operator.

process()

void vital::StereoEncoder::process ( int num_samples )

overridevirtual

Processes the stereo input, either applying rotation or a center/spread mix.

Processes stereo rotation/spread encoding or decoding based on the selected mode.

Parameters

num_samples

Number of samples to process.

Implements vital::Processor.

processCenter()

void vital::StereoEncoder::processCenter ( int num_samples )

protected

Processes the stereo signal in spread/center mode.

Applies a center or spread transform to the stereo signal, blending L and R.

Parameters

num_samples

Number of samples to process.

processRotate()

void vital::StereoEncoder::processRotate ( int num_samples )

protected

Processes the stereo signal in rotate mode (phase rotation).

Applies a rotation transform to the stereo signal (L,R) -> (L*cos - R*sin, R*cos + L*sin).

Parameters

num_samples

Number of samples to process.

Member Data Documentation

cos_mult_

poly_float vital::StereoEncoder::cos_mult_

protected

decoding_mult_

mono_float vital::StereoEncoder::decoding_mult_

protected

sin_mult_

poly_float vital::StereoEncoder::sin_mult_

protected

---

The documentation for this class was generated from the following files:

• /Users/davidvogel/repos/VitalHelp/src/synthesis/framework/operators.h
• /Users/davidvogel/repos/VitalHelp/src/synthesis/framework/operators.cpp