A headless subclass of SynthBase that provides a critical section and pausing capability. More...

#include <synth_base.h>

Inheritance diagram for HeadlessSynth:

Public Member Functions
const CriticalSection &	getCriticalSection () override
	Provides access to the synth’s internal CriticalSection for thread safety.

void	pauseProcessing (bool pause) override
	Pauses or resumes audio processing.

Public Member Functions inherited from SynthBase
	SynthBase ()
	Constructs a SynthBase, initializing the sound engine, MIDI manager, wavetables, and settings.

virtual	~SynthBase ()
	Destroys the SynthBase, cleaning up resources such as sound engine and memory buffers.

void	valueChanged (const std::string &name, vital::mono_float value)
	Updates the value of a control parameter.

void	valueChangedThroughMidi (const std::string &name, vital::mono_float value) override
	Handles parameter changes triggered through MIDI mappings.

void	pitchWheelMidiChanged (vital::mono_float value) override
	Called when the pitch wheel value changes via MIDI.

void	modWheelMidiChanged (vital::mono_float value) override
	Called when the mod wheel value changes via MIDI.

void	pitchWheelGuiChanged (vital::mono_float value)
	Called when the pitch wheel changes via the GUI or another external source.

void	modWheelGuiChanged (vital::mono_float value)
	Called when the mod wheel changes via the GUI or another external source.

void	presetChangedThroughMidi (File preset) override
	Called when a preset is changed through MIDI (e.g., program change messages).

void	valueChangedExternal (const std::string &name, vital::mono_float value)
	Handles external (non-GUI, non-MIDI) value changes to parameters.

void	valueChangedInternal (const std::string &name, vital::mono_float value)
	Handles internal value changes, updating the parameter and optionally notifying the host.

bool	connectModulation (const std::string &source, const std::string &destination)
	Connects a modulation source to a destination parameter.

void	connectModulation (vital::ModulationConnection *connection)
	Connects a modulation using a pre-existing ModulationConnection object.

void	disconnectModulation (const std::string &source, const std::string &destination)
	Disconnects a modulation source from a destination parameter.

void	disconnectModulation (vital::ModulationConnection *connection)
	Disconnects a modulation given a ModulationConnection object.

void	clearModulations ()
	Clears all modulation connections.

void	forceShowModulation (const std::string &source, bool force)
	Forces a modulation source to remain active even if not currently connected.

bool	isModSourceEnabled (const std::string &source)
	Checks if a modulation source is currently enabled.

int	getNumModulations (const std::string &destination)
	Counts how many modulations target a given parameter.

int	getConnectionIndex (const std::string &source, const std::string &destination)
	Gets the index of a modulation connection given its source and destination.

vital::CircularQueue< vital::ModulationConnection * >	getModulationConnections ()
	Gets all current modulation connections as a CircularQueue.

std::vector< vital::ModulationConnection * >	getSourceConnections (const std::string &source)
	Returns all modulation connections from a particular source.

bool	isSourceConnected (const std::string &source)
	Checks if a given modulation source has any active connections.

std::vector< vital::ModulationConnection * >	getDestinationConnections (const std::string &destination)
	Returns all modulation connections targeting a given destination parameter.

const vital::StatusOutput *	getStatusOutput (const std::string &name)
	Retrieves a status output by name.

vital::Wavetable *	getWavetable (int index)
	Gets a wavetable object from the engine.

WavetableCreator *	getWavetableCreator (int index)
	Gets a WavetableCreator for a given oscillator index.

vital::Sample *	getSample ()
	Gets the Sample object used by the engine.

LineGenerator *	getLfoSource (int index)
	Retrieves an LFO source by index.

int	getSampleRate ()
	Retrieves the current audio sample rate used by the engine.

void	initEngine ()
	Initializes the engine to a default state, clearing modulations and resetting parameters.

void	loadTuningFile (const File &file)
	Loads a tuning file into the synthesizer’s tuning system.

void	loadInitPreset ()
	Loads an "init" preset, resetting Vital to its default initial state.

bool	loadFromFile (File preset, std::string &error)
	Attempts to load a preset from a file.

void	renderAudioToFile (File file, float seconds, float bpm, std::vector< int > notes, bool render_images)
	Renders audio to a WAV file for a given duration and note sequence.

void	renderAudioForResynthesis (float *data, int samples, int note)
	Renders audio for the purpose of resynthesis into a provided buffer.

bool	saveToFile (File preset)
	Saves the current preset state to the specified file.

bool	saveToActiveFile ()
	Saves the current preset state to the active file (if any).

void	clearActiveFile ()
	Clears the currently active preset file, meaning changes are not saved to a previously loaded file.

File	getActiveFile ()
	Gets the currently active preset file.

void	setMpeEnabled (bool enabled)
	Enables or disables MPE (MIDI Polyphonic Expression) mode.

virtual void	beginChangeGesture (const std::string &name)
	Called when a parameter change gesture begins. Typically not implemented in this base class.

virtual void	endChangeGesture (const std::string &name)
	Called when a parameter change gesture ends. Typically not implemented in this base class.

virtual void	setValueNotifyHost (const std::string &name, vital::mono_float value)
	Called when a parameter changes to notify a potential host environment. Typically not implemented here.

void	armMidiLearn (const std::string &name)
	Arms the given parameter name for MIDI learn, associating the next received MIDI control with it.

void	cancelMidiLearn ()
	Cancels a previously armed MIDI learn operation.

void	clearMidiLearn (const std::string &name)
	Clears the MIDI mapping for a given parameter name.

bool	isMidiMapped (const std::string &name)
	Checks if a given parameter name is MIDI mapped.

void	setAuthor (const String &author)
	Sets the author metadata of the current preset.

void	setComments (const String &comments)
	Sets the comments or description metadata of the current preset.

void	setStyle (const String &style)
	Sets the style metadata of the current preset (e.g., bass, lead, etc.).

void	setPresetName (const String &preset_name)
	Sets the preset name.

void	setMacroName (int index, const String &macro_name)
	Sets the name of a macro control by index.

String	getAuthor ()
	Gets the author of the current preset.

String	getComments ()
	Gets the comments for the current preset.

String	getStyle ()
	Gets the style of the current preset.

String	getPresetName ()
	Gets the current preset’s name.

String	getMacroName (int index)
	Gets the name of a macro control by index.

vital::control_map &	getControls ()
	Provides access to the controls map (parameter name to Parameter pointer).

vital::SoundEngine *	getEngine ()
	Returns a pointer to the SoundEngine used for audio and modulation processing.

MidiKeyboardState *	getKeyboardState ()
	Retrieves the keyboard state (for processing MIDI note events from a virtual keyboard).

const vital::poly_float *	getOscilloscopeMemory ()
	Retrieves the oscilloscope memory for visualization of audio output waveforms.

const vital::StereoMemory *	getAudioMemory ()
	Retrieves stereo memory holding recent audio output samples for visualization.

const vital::StereoMemory *	getEqualizerMemory ()
	Retrieves memory used for equalizer visualization, if available.

vital::ModulationConnectionBank &	getModulationBank ()
	Retrieves the ModulationConnectionBank managing all modulation connections.

void	notifyOversamplingChanged ()
	Notifies that oversampling settings have changed, reinitializing the engine if needed.

void	checkOversampling ()
	Checks and updates oversampling settings. May be called if parameters affecting oversampling change.

Tuning *	getTuning ()
	Returns a pointer to the synth's Tuning object.

Public Member Functions inherited from MidiManager::Listener
virtual	~Listener ()

Protected Member Functions
SynthGuiInterface *	getGuiInterface () override
	Retrieves the GUI interface if available, for updating controls or notifications.

Protected Member Functions inherited from SynthBase
vital::modulation_change	createModulationChange (vital::ModulationConnection *connection)
	Creates a modulation_change structure for a given connection, preparing it for engine operations.

bool	isInvalidConnection (const vital::modulation_change &change)
	Checks if a modulation_change is invalid (e.g., creates a loop).

json	saveToJson ()
	Serializes the current synth state into a JSON object.

bool	loadFromJson (const json &state)
	Deserializes and applies the synth state from a JSON object.

vital::ModulationConnection *	getConnection (const std::string &source, const std::string &destination)
	Finds a ModulationConnection by source and destination names.

bool	getNextModulationChange (vital::modulation_change &change)
	Attempts to dequeue a modulation_change for processing.

void	clearModulationQueue ()
	Clears the modulation change queue, removing all pending changes.

void	processAudio (AudioSampleBuffer *buffer, int channels, int samples, int offset)
	Processes audio into the given buffer. May be overridden or extended by subclasses.

void	processAudioWithInput (AudioSampleBuffer buffer, const vital::poly_float input_buffer, int channels, int samples, int offset)
	Processes audio with an input buffer, often used for sidechain or feedback loops.

void	writeAudio (AudioSampleBuffer *buffer, int channels, int samples, int offset)
	Writes audio data from the engine to the output buffer.

void	processMidi (MidiBuffer &buffer, int start_sample=0, int end_sample=0)
	Processes MIDI messages from a MidiBuffer, applying them to the engine’s sound generation.

void	processKeyboardEvents (MidiBuffer &buffer, int num_samples)
	Processes keyboard events from a MidiBuffer, integrating them with the MidiKeyboardState.

void	processModulationChanges ()
	Processes pending modulation changes and updates the engine accordingly.

void	updateMemoryOutput (int samples, const vital::poly_float *audio)
	Updates the oscilloscope memory with the latest audio samples.

Additional Inherited Members
Static Public Attributes inherited from SynthBase
static constexpr float	kOutputWindowMinNote = 16.0f
	Minimum and maximum note values considered for output window display or related processing.

static constexpr float	kOutputWindowMaxNote = 128.0f

Protected Attributes inherited from SynthBase
std::unique_ptr< vital::SoundEngine >	engine_

std::unique_ptr< MidiManager >	midi_manager_

std::unique_ptr< MidiKeyboardState >	keyboard_state_

std::unique_ptr< WavetableCreator >	wavetable_creators_ [vital::kNumOscillators]

std::shared_ptr< SynthBase * >	self_reference_

File	active_file_

vital::poly_float	oscilloscope_memory_ [2 *vital::kOscilloscopeMemoryResolution]

vital::poly_float	oscilloscope_memory_write_ [2 *vital::kOscilloscopeMemoryResolution]

std::unique_ptr< vital::StereoMemory >	audio_memory_

vital::mono_float	last_played_note_

int	last_num_pressed_

vital::mono_float	memory_reset_period_

vital::mono_float	memory_input_offset_

int	memory_index_

bool	expired_

std::map< std::string, String >	save_info_

vital::control_map	controls_

vital::CircularQueue< vital::ModulationConnection * >	mod_connections_

moodycamel::ConcurrentQueue< vital::control_change >	value_change_queue_

moodycamel::ConcurrentQueue< vital::modulation_change >	modulation_change_queue_

Tuning	tuning_

Detailed Description

A headless subclass of SynthBase that provides a critical section and pausing capability.

The HeadlessSynth can operate without a GUI, useful in environments like CLI tools, render farms, or automated test rigs. It uses a CriticalSection to manage audio processing safely.

Member Function Documentation

◆ getCriticalSection()

const CriticalSection & HeadlessSynth::getCriticalSection ( )

inlineoverridevirtual

Provides access to the synth’s internal CriticalSection for thread safety.

Must be implemented by subclasses.

Returns: A reference to the CriticalSection.

Implements SynthBase.

◆ getGuiInterface()

SynthGuiInterface * HeadlessSynth::getGuiInterface ( )

inlineoverrideprotectedvirtual

Retrieves the GUI interface if available, for updating controls or notifications.

Returns: A pointer to a SynthGuiInterface, or nullptr if headless.

Implements SynthBase.

◆ pauseProcessing()

void HeadlessSynth::pauseProcessing ( bool pause )

inlineoverridevirtual

Pauses or resumes audio processing.

When paused, processing locks the critical section to avoid concurrency issues.

Parameters

pause True to pause, false to resume.

Implements SynthBase.

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

/Users/davidvogel/repos/VitalHelp/src/common/synth_base.h

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ getCriticalSection()

◆ getGuiInterface()

◆ pauseProcessing()