Processor Class Reference

Advanced audio processor base class with parameter management and preset system. More...

#include <gin_processor.h>

Inherits ProcessorBaseClass, juce::ChangeBroadcaster, and juce::Timer.

Public Member Functions
	Processor (bool init=true, ProcessorOptions={})
	If you override any virtual functions, they won't get called by the constructor.
	Processor (const BusesProperties &ioLayouts, bool init=true, ProcessorOptions={})
	~Processor () override
virtual void	init ()
virtual Program *	createProgram ()
void	reset () override
void	prepareToPlay (double sampleRate, int samplesPerBlock) override
void	releaseResources () override
virtual juce::PropertiesFile *	getSettings ()
void	addPluginParameter (gin::Parameter *parameter)
gin::Parameter *	addExtParam (juce::String uid, juce::String name, juce::String shortName, juce::String label, juce::NormalisableRange< float > range, float defaultValue, SmoothingType st, std::function< juce::String(const gin::Parameter &, float)> textFunction=nullptr)
gin::Parameter *	addIntParam (juce::String uid, juce::String name, juce::String shortName, juce::String label, juce::NormalisableRange< float > range, float defaultValue, SmoothingType st, std::function< juce::String(const gin::Parameter &, float)> textFunction=nullptr)
gin::Parameter *	getParameter (const juce::String &uid)
float	parameterValue (const juce::String &uid)
int	parameterIntValue (const juce::String &uid)
bool	parameterBoolValue (const juce::String &uid)
const juce::Array< gin::Parameter * > &	getPluginParameters ()
bool	isSmoothing ()
virtual bool	isParamLocked (gin::Parameter *)
virtual juce::File	getProgramDirectory ()
virtual void	loadAllPrograms ()
const juce::String	getName () const override
bool	acceptsMidi () const override
bool	producesMidi () const override
double	getTailLengthSeconds () const override
int	getNumPrograms () override
int	getCurrentProgram () override
const juce::OwnedArray< Program > &	getPrograms ()
Program *	getProgram (const juce::String &name)
void	setCurrentProgram (juce::String name)
void	setCurrentProgram (int index) override
const juce::String	getProgramName (int index) override
void	changeProgramName (int index, const juce::String &newName) override
void	saveProgram (juce::String name, juce::String author, juce::String tags)
void	deleteProgram (int index)
bool	hasProgram (juce::String name)
juce::String	getStateXml ()
void	setStateXml (const juce::String &s)
void	getStateInformation (juce::MemoryBlock &destData) override
void	setStateInformation (const void *data, int sizeInBytes) override

Public Attributes
const ProcessorOptions	processorOptions
bool	loadingState = false
std::unique_ptr< juce::LookAndFeel >	lf
std::map< juce::String, gin::Parameter * >	parameterMap
juce::OwnedArray< gin::Parameter >	internalParameters
juce::ValueTree	state
int	versionHint = 1

Protected Member Functions
virtual void	stateUpdated ()
virtual void	updateState ()
void	extractProgram (const juce::String &name, const juce::MemoryBlock &data)
void	extractProgram (const juce::String &name, const void *data, int sz)
void	timerCallback () override
std::unique_ptr< gin::Parameter >	createParam (juce::String uid, juce::String name, juce::String shortName, juce::String label, juce::NormalisableRange< float > range, float defaultValue, SmoothingType st, std::function< juce::String(const gin::Parameter &, float)> textFunction=nullptr)
void	updateParams ()

Protected Attributes
std::unique_ptr< juce::PropertiesFile >	settings
juce::Array< gin::Parameter * >	allParameters
juce::String	currentProgramName
int	maxPrograms = 0
juce::OwnedArray< Program >	programs
juce::Time	lastStateLoad
juce::Time	lastProgramsUpdated

Detailed Description

Advanced audio processor base class with parameter management and preset system.

Processor extends JUCE's AudioProcessor with a complete parameter management system, preset/program handling, state management, and various conveniences for building professional audio plugins.

Key Features:

• Parameter Management: Internal and external parameters with automatic host exposure
• Preset System: Full program/preset management with file watching
• State Management: ValueTree-based state with automatic parameter sync
• Parameter Smoothing: Built-in smoothing for audio-rate parameters
• Settings: Optional persistent settings via PropertiesFile
• Modulation Support: Integration with ModMatrix system
• Update Checking: Optional update and news checking

Parameter Types:

• External Parameters: Exposed to host, automatable, saved in presets
• Internal Parameters: Not exposed to host, for UI-only settings

Preset System: Programs are automatically loaded from a directory and file-watched for changes. Each program stores parameters and can include custom state data.

Usage:

class MyProcessor : public gin::Processor
{
public:
    MyProcessor() : Processor(false) // false = don't auto-init
    {
        // Add parameters
        cutoff = addExtParam("cutoff", "Cutoff", "Cutoff", "Hz",
                             {20.0f, 20000.0f}, 1000.0f,
                             SmoothingType(0.05f));
 
        resonance = addExtParam("resonance", "Resonance", "Res", "",
                                {0.0f, 1.0f}, 0.5f,
                                SmoothingType(0.05f));
 
        init(); // Call after adding all parameters
    }
 
    void prepareToPlay(double sr, int block) override
    {
        Processor::prepareToPlay(sr, block);
        filter.setSampleRate(sr);
    }
 
    void processBlock(AudioBuffer<float>& buffer, MidiBuffer& midi) override
    {
        // Parameters are automatically smoothed
        filter.setCutoff(cutoff->getProcValue());
        filter.setResonance(resonance->getProcValue());
        filter.process(buffer);
    }
 
private:
    Parameter* cutoff;
    Parameter* resonance;
    MyFilter filter;
};

See also

Parameter, Program, ModMatrix

Constructor & Destructor Documentation

Processor() [1/2]

Processor::Processor	(	bool	init = true,
		ProcessorOptions	= {}
	)

If you override any virtual functions, they won't get called by the constructor.

So pass false and then call init manually from your constructor. If you don't override any functions, then it's safe to pass true to the constructor and you don't need to call init.

Processor() [2/2]

Processor::Processor	(	const BusesProperties &	ioLayouts,
		bool	init = true,
		ProcessorOptions	= {}
	)

~Processor()

Processor::~Processor ( )

override

Member Function Documentation

init()

virtual void Processor::init ( )

virtual

createProgram()

virtual Program * Processor::createProgram ( )

virtual

reset()

void Processor::reset ( )

override

prepareToPlay()

void Processor::prepareToPlay ( double  sampleRate, int  samplesPerBlock  )

override

releaseResources()

void Processor::releaseResources ( )

override

getSettings()

virtual juce::PropertiesFile * Processor::getSettings ( )

virtual

addPluginParameter()

void Processor::addPluginParameter

(

gin::Parameter *

parameter

)

addExtParam()

gin::Parameter * Processor::addExtParam	(	juce::String	uid,
		juce::String	name,
		juce::String	shortName,
		juce::String	label,
		juce::NormalisableRange< float >	range,
		float	defaultValue,
		SmoothingType	st,
		std::function< juce::String(const gin::Parameter &, float)>	textFunction = nullptr
	)

addIntParam()

gin::Parameter * Processor::addIntParam	(	juce::String	uid,
		juce::String	name,
		juce::String	shortName,
		juce::String	label,
		juce::NormalisableRange< float >	range,
		float	defaultValue,
		SmoothingType	st,
		std::function< juce::String(const gin::Parameter &, float)>	textFunction = nullptr
	)

getParameter()

gin::Parameter * Processor::getParameter

(

const juce::String &

uid

)

parameterValue()

float Processor::parameterValue

(

const juce::String &

uid

)

parameterIntValue()

int Processor::parameterIntValue

(

const juce::String &

uid

)

parameterBoolValue()

bool Processor::parameterBoolValue

(

const juce::String &

uid

)

getPluginParameters()

const juce::Array< gin::Parameter * > & Processor::getPluginParameters

(

)

isSmoothing()

bool Processor::isSmoothing

(

)

isParamLocked()

virtual bool Processor::isParamLocked ( gin::Parameter *  )

virtual

getProgramDirectory()

virtual juce::File Processor::getProgramDirectory ( )

virtual

loadAllPrograms()

virtual void Processor::loadAllPrograms ( )

virtual

getName()

const juce::String Processor::getName ( ) const

override

acceptsMidi()

bool Processor::acceptsMidi ( ) const

override

producesMidi()

bool Processor::producesMidi ( ) const

override

getTailLengthSeconds()

double Processor::getTailLengthSeconds ( ) const

override

getNumPrograms()

int Processor::getNumPrograms ( )

override

getCurrentProgram()

int Processor::getCurrentProgram ( )

override

getPrograms()

const juce::OwnedArray< Program > & Processor::getPrograms

(

)

References programs.

getProgram()

Program * Processor::getProgram

(

const juce::String &

name

)

setCurrentProgram() [1/2]

void Processor::setCurrentProgram

(

juce::String

name

)

setCurrentProgram() [2/2]

void Processor::setCurrentProgram ( int  index )

override

getProgramName()

const juce::String Processor::getProgramName ( int  index )

override

changeProgramName()

void Processor::changeProgramName ( int  index, const juce::String &  newName  )

override

saveProgram()

void Processor::saveProgram	(	juce::String	name,
		juce::String	author,
		juce::String	tags
	)

deleteProgram()

void Processor::deleteProgram

(

int

index

)

hasProgram()

bool Processor::hasProgram

(

juce::String

name

)

getStateXml()

juce::String Processor::getStateXml

(

)

setStateXml()

void Processor::setStateXml

(

const juce::String &

s

)

getStateInformation()

void Processor::getStateInformation ( juce::MemoryBlock &  destData )

override

setStateInformation()

void Processor::setStateInformation ( const void *  data, int  sizeInBytes  )

override

stateUpdated()

virtual void Processor::stateUpdated ( )

protectedvirtual

updateState()

virtual void Processor::updateState ( )

protectedvirtual

extractProgram() [1/2]

void Processor::extractProgram ( const juce::String &  name, const juce::MemoryBlock &  data  )

protected

extractProgram() [2/2]

void Processor::extractProgram ( const juce::String &  name, const void *  data, int  sz  )

protected

timerCallback()

void Processor::timerCallback ( )

overrideprotected

createParam()

std::unique_ptr< gin::Parameter > Processor::createParam ( juce::String  uid, juce::String  name, juce::String  shortName, juce::String  label, juce::NormalisableRange< float >  range, float  defaultValue, SmoothingType  st, std::function< juce::String(const gin::Parameter &, float)>  textFunction = nullptr  )

protected

updateParams()

void Processor::updateParams ( )

protected

Member Data Documentation

processorOptions

const ProcessorOptions Processor::processorOptions

loadingState

bool Processor::loadingState = false

lf

std::unique_ptr<juce::LookAndFeel> Processor::lf

parameterMap

std::map<juce::String, gin::Parameter*> Processor::parameterMap

internalParameters

juce::OwnedArray<gin::Parameter> Processor::internalParameters

state

juce::ValueTree Processor::state

Referenced by ProcessorEditorBase::makeResizable(), and ProcessorEditorBase::resized().

versionHint

int Processor::versionHint = 1

settings

std::unique_ptr<juce::PropertiesFile> Processor::settings

protected

allParameters

juce::Array<gin::Parameter*> Processor::allParameters

protected

currentProgramName

juce::String Processor::currentProgramName

protected

maxPrograms

int Processor::maxPrograms = 0

protected

programs

juce::OwnedArray<Program> Processor::programs

protected

Referenced by getPrograms().

lastStateLoad

juce::Time Processor::lastStateLoad

protected

lastProgramsUpdated

juce::Time Processor::lastProgramsUpdated

protected

---

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

• gin_processor.h