zyncarla Namespace Reference

Namespaces
namespace	Nio

Classes
struct	QueueListItem
class	LockFreeQueue
class	MultiQueue
class	NotePool
struct	ScratchString
class	AnalogFilter
class	FFTwrapper
class	Filter
class	FormantFilter
class	SVFilter
class	Unison
class	Alienwah
class	Chorus
class	Distorsion
class	DynamicFilter
class	Echo
struct	EffectParams
class	Effect
class	EffectLFO
class	EffectMgr
class	EQ
class	Phaser
class	Reverb
class	m_unique_ptr
struct	SYNTH_T
struct	next_t
struct	AllocatorImpl
struct	block_header_t
class	Allocator
class	AllocatorClass
	the allocator for normal use More...
class	DummyAllocator
	the dummy allocator, which does not allow any allocation More...
class	Bank
struct	BankEntry
class	BankDb
struct	CallbackRepeater
class	oss_devs_t
class	Config
class	LASHClient
class	DataObj
struct	vuData
class	Master
struct	KbmInfo
struct	OctaveTuning
struct	SclInfo
class	Microtonal
struct	NonRtObjStore
struct	ParamStore
class	MiddleWareImpl
class	MwDataObj
class	MiddleWare
class	Part
class	Capture
struct	Clipboard
class	Recorder
struct	Stereo
class	AbsTime
class	RelTime
class	WavFile
class	XmlAttr
class	XmlNode
class	XMLwrapper
class	AlsaEngine
class	AudioOut
class	Engine
class	EngineMgr
struct	MidiEvent
class	InMgr
class	JackEngine
struct	jack_multi
class	JackMultiEngine
class	MidiIn
class	NulEngine
struct	OssMidiParse
class	OssEngine
class	OssMultiEngine
class	OutMgr
class	PaEngine
class	SafeQueue
class	WavEngine
class	ZynSema
struct	ADnoteGlobalParam
struct	ADnoteVoiceParam
class	ADnoteParameters
class	Controller
struct	version_fixer_t
class	EnvelopeParams
class	FilterParams
class	LFOParams
struct	Sample
class	Presets
class	PresetsArray
class	PresetsStore
class	SUBnoteParameters
class	ADnote
class	Envelope
class	LFO
class	ModFilter
class	OscilGen
class	PADnote
class	Resonance
class	SUBnote
struct	SynthParams
struct	LegatoParams
class	SynthNote
struct	WatchPoint
struct	WatchManager
struct	FloatWatchPoint
struct	VecWatchPoint
class	version_type
	class containing a zynaddsubfx version More...
struct	complex
struct	RtData
	data object for the dispatch routine More...
struct	Ports

Typedefs
typedef struct QueueListItem	qli_t
typedef double	fftw_real
typedef std::complex< fftw_real >	fft_t
typedef struct zyncarla::block_header_t	block_header_t
typedef AllocatorClass	Alloc
typedef BankDb::svec	svec
typedef BankDb::bvec	bvec
typedef void(*	cb_t) (void *, const char *)
typedef uint32_t	prng_t
typedef jack_default_audio_sample_t	jsample_t
typedef std::function< void(int, PADnoteParameters::Sample &)>	callback
typedef float(*	base_func) (float, float)
typedef float(*	filter_func) (unsigned int, float, float)

Enumerations
enum	NoteStatus { KEY_OFF = 0x00 , KEY_PLAYING = 0x01 , KEY_RELEASED_AND_SUSTAINED = 0x02 , KEY_RELEASED = 0x03 }
enum	ONOFFTYPE { OFF = 0 , ON = 1 }
enum	MidiControllers {   C_bankselectmsb = 0 , C_pitchwheel = 1000 , C_NULL = 1001 , C_expression = 11 ,   C_panning = 10 , C_bankselectlsb = 32 , C_filtercutoff = 74 , C_filterq = 71 ,   C_bandwidth = 75 , C_modwheel = 1 , C_fmamp = 76 , C_volume = 7 ,   C_sustain = 64 , C_allnotesoff = 123 , C_allsoundsoff = 120 , C_resetallcontrollers = 121 ,   C_portamento = 65 , C_resonance_center = 77 , C_resonance_bandwidth = 78 , C_dataentryhi = 0x06 ,   C_dataentrylo = 0x26 , C_nrpnhi = 99 , C_nrpnlo = 98 }
enum	LegatoMsg {   LM_Norm , LM_FadeIn , LM_FadeOut , LM_CatchUp ,   LM_ToNorm }
enum	midi_type { M_NOTE = 1 , M_CONTROLLER = 2 , M_PGMCHANGE = 3 , M_PRESSURE = 4 }
enum	FMTYPE {   NONE , MORPH , RING_MOD , PHASE_MOD ,   FREQ_MOD , PW_MOD }

Functions
static int	getMergeableDescriptor (uint8_t note, uint8_t sendto, bool legato, NotePool::NoteDescriptor *ndesc)
const char *	getStatus (int status_bits)
void	AnalogBiquadFilterA (const float coeff[5], float &src, float work[4])
void	AnalogBiquadFilterB (const float coeff[5], float &src, float work[4])
void	FFT_cleanup ()
template<class _Tp>
std::complex< _Tp >	FFTpolar (const _Tp &__rho, const _Tp &__theta=_Tp(0))
float	log_2 (float x)
int	max (int a, int b)
void	dump_json (std::ostream &o, const rtosc::Ports &p)
void *	data (next_t *n)
bool	platform_strcasestr (const char *hay, const char *needle)
bool	sfind (std::string hay, std::string needle)
static svec	split (string s)
static std::string	getCacheName (void)
static bvec	loadCache (void)
static void	saveCache (bvec vec)
static int	extract_num (const char *&msg)
static int	get_next_int (const char *msg)
static rtosc_version	version_in_rtosc_fmt ()
string	loadfile (string fname)
static void	liblo_error_cb (int i, const char *m, const char *loc)
void	path_search (const char *m, const char *url)
static int	handler_function (const char *path, const char *types, lo_arg **argv, int argc, lo_message msg, void *user_data)
template<class T, class V>
std::vector< T >	keys (const std::map< T, V > &m)
void	deallocate (const char *str, void *v)
void	preparePadSynth (string path, PADnoteParameters *p, rtosc::RtData &d)
static std::vector< std::string >	getFiles (const char *folder, bool finddir)
static int	extractInt (const char *msg)
static const char *	chomp (const char *msg)
static void	assert_kit_sanity (const Part::Kit *kits)
static int	kit_usage (const Part::Kit *kits, int note, int mode)
static void	dummy (const char *, rtosc::RtData &)
template<class T>
T	capture (Master *m, std::string url)
template<>
std::string	capture (Master *m, std::string url)
template<>
void *	capture (Master *m, std::string url)
template<class T>
std::string	doCopy (MiddleWare &mw, string url, string name)
template<class T, typename... Ts>
void	doPaste (MiddleWare &mw, string url, string type, XMLwrapper &xml, Ts &&... args)
template<class T>
std::string	doArrayCopy (MiddleWare &mw, int field, string url, string name)
template<class T, typename... Ts>
void	doArrayPaste (MiddleWare &mw, int field, string url, string type, XMLwrapper &xml, Ts &&... args)
void	doClassPaste (std::string type, std::string type_, MiddleWare &mw, string url, XMLwrapper &data)
std::string	doClassCopy (std::string type, MiddleWare &mw, string url, string name)
void	doClassArrayPaste (std::string type, std::string type_, int field, MiddleWare &mw, string url, XMLwrapper &data)
std::string	doClassArrayCopy (std::string type, int field, MiddleWare &mw, string url, string name)
std::string	getUrlPresetType (std::string url, MiddleWare &mw)
std::string	getUrlType (std::string url)
void	presetCopy (MiddleWare &mw, std::string url, std::string name)
void	presetPaste (MiddleWare &mw, std::string url, std::string name)
void	presetCopyArray (MiddleWare &mw, std::string url, int field, std::string name)
void	presetPasteArray (MiddleWare &mw, std::string url, int field, std::string name)
void	presetDelete (int)
void	presetRescan ()
std::string	presetClipboardType ()
bool	presetCheckClipboardType ()
Clipboard	clipboardCopy (class MiddleWare &mw, std::string url)
void	presetPaste (std::string url, int)
static const char *	escape_string (const char *msg)
void	dump_param_cb (const rtosc::Port *p, const char *full_name, const char *, const Ports &, void *v, void *)
float	VelF (float velocity, unsigned char scaling)
float	getdetune (unsigned char type, unsigned short int coarsedetune, unsigned short int finedetune)
bool	fileexists (const char *filename)
void	set_realtime ()
void	os_usleep (long length)
std::size_t	os_guess_pid_length ()
	returns pid padded, posix conform
std::string	os_pid_as_padded_string ()
	returns pid padded to maximum pid lenght, posix conform
std::string	legalizeFilename (std::string filename)
void	invSignal (float *sig, size_t len)
float	interpolate (const float *data, size_t len, float pos)
float	cinterpolate (const float *data, size_t len, float pos)
char *	rtosc_splat (const char *path, std::set< std::string > v)
template<class T>
std::string	stringFrom (T x)
template<class T>
std::string	to_s (T x)
template<class T>
T	stringTo (const char *x)
template<class T>
T	limit (T val, T min, T max)
template<class T>
bool	inRange (T val, T min, T max)
template<class T>
T	array_max (const T *data, size_t len)
prng_t	prng_r (prng_t &p)
prng_t	prng (void)
void	sprng (prng_t p)
template<class T>
static void	nullify (T &t)
template<class T>
static void	arrayNullify (T &t)
void	waveShapeSmps (int n, float *smps, unsigned char type, unsigned char drive)
const char *	XMLwrapper_whitespace_callback (mxml_node_t *node, int where)
const mxml_node_t *	mxmlFindElement (const mxml_node_t *node, const mxml_node_t *top, const char *name, const char *attr, const char *value, int descend)
const char *	mxmlElementGetAttr (const mxml_node_t *node, const char *name)
const char *	trimLeadingWhite (const char *c)
ostream &	operator<< (ostream &out, const MidiEvent &ev)
static unsigned char	OssMidiParse (struct OssMidiParse &midi_parse, unsigned char cn, unsigned char b)
static size_t	resample (float *dest, const float *src, float s_in, float s_out, size_t elms)
void	PAfinish ()
static void	normalize_max (float *f, size_t len)
static float	Pbwscale_translate (char Pbwscale)
float	setPbandwidth (int Pbandwidth)
	Return the BandWidth in cents Get the n-th overtone position relatively to N harmonic.
float	getNhr (int n) const
void	applyparameters (void)
void	applyparameters (std::function< bool()> do_abort, unsigned max_threads=0)
	Compute the sample array from the other parameters. For the function's parameters, see sampleGenerator().
void	export2wav (std::string basefilename)
int	sampleGenerator (PADnoteParameters::callback cb, std::function< bool()> do_abort, unsigned max_threads=0)
	PAD synth main function Generate spectrum and run IFFTs on it.
void	generatespectrum_bandwidthMode (float *spectrum, int size, float basefreq, const float *profile, int profilesize, float bwadjust) const
void	generatespectrum_otherModes (float *spectrum, int size, float basefreq) const
void	deletesamples ()
void	deletesample (int n)
static int	current_category (Filter *f)
void	clearAll (fft_t *freqs, int oscilsize)
void	clearDC (fft_t *freqs)
float	normal (const fft_t *freqs, off_t x)
float	abs (const fft_t *freqs, off_t x)
float	arg (const fft_t *freqs, off_t x)
void	normalize (fft_t *freqs, int oscilsize)
void	rmsNormalize (fft_t *freqs, int oscilsize)
void	normalize (float *smps, size_t N)
fft_t	operator* (float a, fft_t b)
	FUNC (pulse)
	FUNC (saw)
	FUNC (triangle)
	FUNC (power)
	FUNC (gauss)
	FUNC (diode)
	FUNC (abssine)
	FUNC (pulsesine)
	FUNC (stretchsine)
	FUNC (chirp)
	FUNC (absstretchsine)
	FUNC (chebyshev)
	FUNC (sqr)
	FUNC (spike)
	FUNC (circle)
base_func	getBaseFunction (unsigned char func)
	FILTER (lp)
	FILTER (hp1)
	FILTER (hp1b)
	FILTER (bp1)
	FILTER (bs1)
	FILTER (lp2)
	FILTER (hp2)
	FILTER (bp2)
	FILTER (bs2)
bool	floatEq (float a, float b)
	FILTER (cos)
	FILTER (sin)
	FILTER (low_shelf)
	FILTER (s)
filter_func	getFilter (unsigned char func)
void	SubFilterA (const float coeff[4], float &src, float work[4])
void	SubFilterB (const float coeff[4], float &src, float work[4])
std::ostream &	operator<< (std::ostream &os, const version_type &v)

Variables
static pthread_mutex_t *	mutex = NULL
static const rtosc::Ports	local_ports
static rtosc::Ports	filterports
int	Pexitprogram = 0
DummyAllocator	DummyAlloc
static const size_t	block_header_free_bit = 1 << 0
static const char *	INSTRUMENT_EXTENSION = ".xiz"
const char *	FORCE_BANK_DIR_FILE = ".bankdir"
static const char *	INSTRUMENT_EXTENSION = ".xiz"
static const rtosc::Ports	ports
static const Ports	sysefxPort
static const Ports	sysefsendto
static const Ports	mapping_ports
static const Ports	auto_param_ports
static const Ports	slot_ports
static const Ports	automate_ports
static const Ports	watchPorts
const Ports	bankPorts
static const Ports	master_ports
int	msg_id =0
static rtosc::Ports	middwareSnoopPorts
static rtosc::Ports	middlewareReplyPorts
static const Ports	partPorts
static const Ports	kitPorts
const rtosc::Ports	real_preset_ports
const rtosc::Ports	preset_ports
static bool	first = true
bool	isPlugin = false
prng_t	prng_state = 0x1234
constexpr std::size_t	max_pid_len = 12
	safe pid lenght guess, posix conform
int	xml_k = 0
bool	verbose = false
InMgr *	in = NULL
OutMgr *	out = NULL
EngineMgr *	eng = NULL
string	postfix
static const Ports	voicePorts
static const Ports	globalPorts
static const Ports	adPorts
static const rtosc::Ports	localPorts
constexpr int	sizeof_pvowels = sizeof(FilterParams::Pvowels)
static const rtosc::Ports	subsubports
static const rtosc::Ports	subports
static const rtosc::Ports	_ports
static const rtosc::Ports	realtime_ports
static const rtosc::Ports	non_realtime_ports
unsigned char	PfixedfreqET
unsigned char	PBendAdjust
unsigned char	POffsetHz
unsigned short int	PDetune
unsigned short int	PCoarseDetune
unsigned char	PDetuneType
EnvelopeParams *	FreqEnvelope
LFOParams *	FreqLfo
unsigned char	PStereo
unsigned char	PPanning
unsigned char	PVolume
unsigned char	PAmpVelocityScaleFunction
EnvelopeParams *	AmpEnvelope
LFOParams *	AmpLfo
unsigned char	Fadein_adjustment
unsigned char	PPunchStrength
unsigned char	PPunchTime
unsigned char	PPunchStretch
unsigned char	PPunchVelocitySensing
FilterParams *	GlobalFilter
unsigned char	PFilterVelocityScale
unsigned char	PFilterVelocityScaleFunction
EnvelopeParams *	FilterEnvelope
LFOParams *	FilterLfo
OscilGen *	oscilgen
Resonance *	resonance
Sample	sample [PAD_MAX_SAMPLES]
	RT sample data.
const AbsTime *	time
int64_t	last_update_timestamp
static const rtosc::MergePorts	ports
static const rtosc::Ports &	non_realtime_ports
static const rtosc::Ports &	realtime_ports
const SYNTH_T &	synth
static const rtosc::Ports	SUBnotePorts
constexpr version_type	version
	the current zynaddsubfx version

Typedef Documentation

Alloc

typedef AllocatorClass zyncarla::Alloc

base_func

typedef float(* zyncarla::base_func)(float, float)

block_header_t

typedef struct zyncarla::block_header_t zyncarla::block_header_t

bvec

typedef BankDb::bvec zyncarla::bvec

callback

typedef std::function<void(int,PADnoteParameters::Sample&)> zyncarla::callback

cb_t

typedef void(* zyncarla::cb_t) (void *, const char *)

fft_t

typedef std::complex<fftw_real> zyncarla::fft_t

fftw_real

typedef double zyncarla::fftw_real

filter_func

typedef float(* zyncarla::filter_func)(unsigned int, float, float)

jsample_t

typedef jack_default_audio_sample_t zyncarla::jsample_t

prng_t

typedef uint32_t zyncarla::prng_t

qli_t

typedef struct QueueListItem zyncarla::qli_t

svec

typedef BankDb::svec zyncarla::svec

Enumeration Type Documentation

FMTYPE

enum zyncarla::FMTYPE

Enumerator
NONE
MORPH
RING_MOD
PHASE_MOD
FREQ_MOD
PW_MOD

LegatoMsg

enum zyncarla::LegatoMsg

Enumerator
LM_Norm
LM_FadeIn
LM_FadeOut
LM_CatchUp
LM_ToNorm

midi_type

enum zyncarla::midi_type

Enumerator
M_NOTE
M_CONTROLLER
M_PGMCHANGE
M_PRESSURE

MidiControllers

enum zyncarla::MidiControllers

Enumerator
C_bankselectmsb
C_pitchwheel
C_NULL
C_expression
C_panning
C_bankselectlsb
C_filtercutoff
C_filterq
C_bandwidth
C_modwheel
C_fmamp
C_volume
C_sustain
C_allnotesoff
C_allsoundsoff
C_resetallcontrollers
C_portamento
C_resonance_center
C_resonance_bandwidth
C_dataentryhi
C_dataentrylo
C_nrpnhi
C_nrpnlo

NoteStatus

enum zyncarla::NoteStatus

Enumerator
KEY_OFF
KEY_PLAYING
KEY_RELEASED_AND_SUSTAINED
KEY_RELEASED

ONOFFTYPE

enum zyncarla::ONOFFTYPE

Enumerator
OFF
ON

Function Documentation

abs()

float zyncarla::abs ( const fft_t * freqs, off_t x )

inline

AnalogBiquadFilterA()

void zyncarla::AnalogBiquadFilterA ( const float coeff[5], float & src, float work[4] )

inline

AnalogBiquadFilterB()

void zyncarla::AnalogBiquadFilterB ( const float coeff[5], float & src, float work[4] )

inline

applyparameters() [1/2]

void zyncarla::applyparameters	(	std::function< bool()>	do_abort,
		unsigned	max_threads = 0 )

Compute the sample array from the other parameters. For the function's parameters, see sampleGenerator().

applyparameters() [2/2]

void zyncarla::applyparameters

(

void

)

arg()

float zyncarla::arg ( const fft_t * freqs, off_t x )

inline

array_max()

template<class T>

T zyncarla::array_max	(	const T *	data,
		size_t	len )

arrayNullify()

template<class T>

void zyncarla::arrayNullify ( T & t )

inlinestatic

assert_kit_sanity()

void zyncarla::assert_kit_sanity ( const Part::Kit * kits )

static

capture() [1/3]

template<>

void * zyncarla::capture	(	Master *	m,
		std::string	url )

capture() [2/3]

template<>

std::string zyncarla::capture	(	Master *	m,
		std::string	url )

capture() [3/3]

template<class T>

T zyncarla::capture	(	Master *	m,
		std::string	url )

chomp()

const char * zyncarla::chomp ( const char * msg )

static

cinterpolate()

float zyncarla::cinterpolate	(	const float *	data,
		size_t	len,
		float	pos )

clearAll()

void zyncarla::clearAll ( fft_t * freqs, int oscilsize )

inline

clearDC()

void zyncarla::clearDC ( fft_t * freqs )

inline

clipboardCopy()

Clipboard zyncarla::clipboardCopy	(	class MiddleWare &	mw,
		std::string	url )

current_category()

int zyncarla::current_category ( Filter * f )

static

data()

void * zyncarla::data

(

next_t *

n

)

deallocate()

void zyncarla::deallocate	(	const char *	str,
		void *	v )

deletesample()

void zyncarla::deletesample ( int n )

private

deletesamples()

void zyncarla::deletesamples ( )

private

doArrayCopy()

template<class T>

std::string zyncarla::doArrayCopy	(	MiddleWare &	mw,
		int	field,
		string	url,
		string	name )

doArrayPaste()

template<class T, typename... Ts>

void zyncarla::doArrayPaste	(	MiddleWare &	mw,
		int	field,
		string	url,
		string	type,
		XMLwrapper &	xml,
		Ts &&...	args )

doClassArrayCopy()

std::string zyncarla::doClassArrayCopy	(	std::string	type,
		int	field,
		MiddleWare &	mw,
		string	url,
		string	name )

doClassArrayPaste()

void zyncarla::doClassArrayPaste	(	std::string	type,
		std::string	type_,
		int	field,
		MiddleWare &	mw,
		string	url,
		XMLwrapper &	data )

doClassCopy()

std::string zyncarla::doClassCopy	(	std::string	type,
		MiddleWare &	mw,
		string	url,
		string	name )

doClassPaste()

void zyncarla::doClassPaste	(	std::string	type,
		std::string	type_,
		MiddleWare &	mw,
		string	url,
		XMLwrapper &	data )

doCopy()

template<class T>

std::string zyncarla::doCopy	(	MiddleWare &	mw,
		string	url,
		string	name )

doPaste()

template<class T, typename... Ts>

void zyncarla::doPaste	(	MiddleWare &	mw,
		string	url,
		string	type,
		XMLwrapper &	xml,
		Ts &&...	args )

dummy()

void zyncarla::dummy ( const char * , rtosc::RtData &  )

static

dump_json()

void zyncarla::dump_json	(	std::ostream &	o,
		const rtosc::Ports &	p )

dump_param_cb()

void zyncarla::dump_param_cb	(	const rtosc::Port *	p,
		const char *	full_name,
		const char *	,
		const Ports &	,
		void *	v,
		void *	)

escape_string()

const char * zyncarla::escape_string ( const char * msg )

static

export2wav()

void zyncarla::export2wav

(

std::string

basefilename

)

extract_num()

int zyncarla::extract_num ( const char *& msg )

static

extractInt()

int zyncarla::extractInt ( const char * msg )

static

FFT_cleanup()

void zyncarla::FFT_cleanup

(

)

FFTpolar()

template<class _Tp>

std::complex< _Tp > zyncarla::FFTpolar	(	const _Tp &	__rho,
		const _Tp &	__theta = _Tp(0) )

fileexists()

bool zyncarla::fileexists

(

const char *

filename

)

FILTER() [1/13]

zyncarla::FILTER

(

bp1

)

FILTER() [2/13]

zyncarla::FILTER

(

bp2

)

FILTER() [3/13]

zyncarla::FILTER

(

bs1

)

FILTER() [4/13]

zyncarla::FILTER

(

bs2

)

FILTER() [5/13]

zyncarla::FILTER

(

cos

)

FILTER() [6/13]

zyncarla::FILTER

(

hp1

)

FILTER() [7/13]

zyncarla::FILTER

(

hp1b

)

FILTER() [8/13]

zyncarla::FILTER

(

hp2

)

FILTER() [9/13]

zyncarla::FILTER

(

low_shelf

)

FILTER() [10/13]

zyncarla::FILTER

(

lp

)

FILTER() [11/13]

zyncarla::FILTER

(

lp2

)

FILTER() [12/13]

zyncarla::FILTER

(

s

)

FILTER() [13/13]

zyncarla::FILTER

(

sin

)

floatEq()

bool zyncarla::floatEq	(	float	a,
		float	b )

FUNC() [1/15]

zyncarla::FUNC

(

abssine

)

FUNC() [2/15]

zyncarla::FUNC

(

absstretchsine

)

FUNC() [3/15]

zyncarla::FUNC

(

chebyshev

)

FUNC() [4/15]

zyncarla::FUNC

(

chirp

)

FUNC() [5/15]

zyncarla::FUNC

(

circle

)

FUNC() [6/15]

zyncarla::FUNC

(

diode

)

FUNC() [7/15]

zyncarla::FUNC

(

gauss

)

FUNC() [8/15]

zyncarla::FUNC

(

power

)

FUNC() [9/15]

zyncarla::FUNC

(

pulse

)

FUNC() [10/15]

zyncarla::FUNC

(

pulsesine

)

FUNC() [11/15]

zyncarla::FUNC

(

saw

)

FUNC() [12/15]

zyncarla::FUNC

(

spike

)

FUNC() [13/15]

zyncarla::FUNC

(

sqr

)

FUNC() [14/15]

zyncarla::FUNC

(

stretchsine

)

FUNC() [15/15]

zyncarla::FUNC

(

triangle

)

generatespectrum_bandwidthMode()

void zyncarla::generatespectrum_bandwidthMode ( float * spectrum, int size, float basefreq, const float * profile, int profilesize, float bwadjust ) const

private

generatespectrum_otherModes()

void zyncarla::generatespectrum_otherModes ( float * spectrum, int size, float basefreq ) const

private

get_next_int()

int zyncarla::get_next_int ( const char * msg )

static

getBaseFunction()

base_func zyncarla::getBaseFunction

(

unsigned char

func

)

getCacheName()

std::string zyncarla::getCacheName ( void )

static

getdetune()

float zyncarla::getdetune	(	unsigned char	type,
		unsigned short int	coarsedetune,
		unsigned short int	finedetune )

getFiles()

std::vector< std::string > zyncarla::getFiles ( const char * folder, bool finddir )

static

getFilter()

filter_func zyncarla::getFilter

(

unsigned char

func

)

getMergeableDescriptor()

int zyncarla::getMergeableDescriptor ( uint8_t note, uint8_t sendto, bool legato, NotePool::NoteDescriptor * ndesc )

static

getNhr()

float zyncarla::getNhr

(

int

n

)

const

getStatus()

const char * zyncarla::getStatus

(

int

status_bits

)

getUrlPresetType()

std::string zyncarla::getUrlPresetType	(	std::string	url,
		MiddleWare &	mw )

getUrlType()

std::string zyncarla::getUrlType

(

std::string

url

)

handler_function()

int zyncarla::handler_function ( const char * path, const char * types, lo_arg ** argv, int argc, lo_message msg, void * user_data )

static

inRange()

template<class T>

bool zyncarla::inRange	(	T	val,
		T	min,
		T	max )

interpolate()

float zyncarla::interpolate	(	const float *	data,
		size_t	len,
		float	pos )

invSignal()

void zyncarla::invSignal	(	float *	sig,
		size_t	len )

keys()

template<class T, class V>

std::vector< T > zyncarla::keys

(

const std::map< T, V > &

m

)

kit_usage()

int zyncarla::kit_usage ( const Part::Kit * kits, int note, int mode )

static

legalizeFilename()

std::string zyncarla::legalizeFilename

(

std::string

filename

)

liblo_error_cb()

void zyncarla::liblo_error_cb ( int i, const char * m, const char * loc )

static

limit()

template<class T>

T zyncarla::limit	(	T	val,
		T	min,
		T	max )

loadCache()

bvec zyncarla::loadCache ( void )

static

loadfile()

string zyncarla::loadfile

(

string

fname

)

log_2()

float zyncarla::log_2 ( float x )

inline

max()

int zyncarla::max ( int a, int b )

inline

mxmlElementGetAttr()

const char * zyncarla::mxmlElementGetAttr	(	const mxml_node_t *	node,
		const char *	name )

mxmlFindElement()

const mxml_node_t * zyncarla::mxmlFindElement	(	const mxml_node_t *	node,
		const mxml_node_t *	top,
		const char *	name,
		const char *	attr,
		const char *	value,
		int	descend )

normal()

float zyncarla::normal ( const fft_t * freqs, off_t x )

inline

normalize() [1/2]

void zyncarla::normalize	(	fft_t *	freqs,
		int	oscilsize )

Take frequency spectrum and ensure values are normalized based upon magnitude to 0<=x<=1

normalize() [2/2]

void zyncarla::normalize ( float * smps, size_t N )

inline

normalize_max()

void zyncarla::normalize_max ( float * f, size_t len )

static

nullify()

template<class T>

void zyncarla::nullify ( T & t )

inlinestatic

operator*()

fft_t zyncarla::operator*	(	float	a,
		fft_t	b )

operator<<() [1/2]

ostream & zyncarla::operator<<	(	ostream &	out,
		const MidiEvent &	ev )

operator<<() [2/2]

std::ostream & zyncarla::operator<<	(	std::ostream &	os,
		const version_type &	v )

os_guess_pid_length()

std::size_t zyncarla::os_guess_pid_length

(

)

returns pid padded, posix conform

os_pid_as_padded_string()

std::string zyncarla::os_pid_as_padded_string

(

)

returns pid padded to maximum pid lenght, posix conform

os_usleep()

void zyncarla::os_usleep

(

long

length

)

maximum lenght a pid has on any POSIX system this is an estimation, but more than 12 looks insane

Os independent sleep in microsecond

OssMidiParse()

unsigned char zyncarla::OssMidiParse ( struct OssMidiParse & midi_parse, unsigned char cn, unsigned char b )

static

PAfinish()

void zyncarla::PAfinish

(

)

path_search()

void zyncarla::path_search	(	const char *	m,
		const char *	url )

Pbwscale_translate()

float zyncarla::Pbwscale_translate ( char Pbwscale )

static

platform_strcasestr()

bool zyncarla::platform_strcasestr	(	const char *	hay,
		const char *	needle )

preparePadSynth()

void zyncarla::preparePadSynth	(	string	path,
		PADnoteParameters *	p,
		rtosc::RtData &	d )

presetCheckClipboardType()

bool zyncarla::presetCheckClipboardType

(

)

presetClipboardType()

std::string zyncarla::presetClipboardType

(

)

presetCopy()

void zyncarla::presetCopy	(	MiddleWare &	mw,
		std::string	url,
		std::string	name )

presetCopyArray()

void zyncarla::presetCopyArray	(	MiddleWare &	mw,
		std::string	url,
		int	field,
		std::string	name )

presetDelete()

void zyncarla::presetDelete

(

int

)

presetPaste() [1/2]

void zyncarla::presetPaste	(	MiddleWare &	mw,
		std::string	url,
		std::string	name )

presetPaste() [2/2]

void zyncarla::presetPaste	(	std::string	url,
		int	)

presetPasteArray()

void zyncarla::presetPasteArray	(	MiddleWare &	mw,
		std::string	url,
		int	field,
		std::string	name )

presetRescan()

void zyncarla::presetRescan

(

)

prng()

prng_t zyncarla::prng ( void )

inline

prng_r()

prng_t zyncarla::prng_r ( prng_t & p )

inline

resample()

size_t zyncarla::resample ( float * dest, const float * src, float s_in, float s_out, size_t elms )

static

rmsNormalize()

void zyncarla::rmsNormalize	(	fft_t *	freqs,
		int	oscilsize )

rtosc_splat()

char * zyncarla::rtosc_splat	(	const char *	path,
		std::set< std::string >	v )

sampleGenerator()

int PADnoteParameters::sampleGenerator	(	PADnoteParameters::callback	cb,
		std::function< bool()>	do_abort,
		unsigned	max_threads = 0 )

PAD synth main function Generate spectrum and run IFFTs on it.

Parameters

cb	A callback that will be executed for each sample buffer Note that this function can be executed by multiple threads at the same time, so make sure you use mutexes etc where required
do_abort	Function that decides whether the calculation should be aborted (probably because of interruptions by the user)
max_threads	Maximum number of threads for computation, or zero if no maximum shall be set

saveCache()

void zyncarla::saveCache ( bvec vec )

static

set_realtime()

void zyncarla::set_realtime

(

)

Try to set current thread to realtime priority program priority

Todo

see if the right pid is being sent

see if this is having desired effect, if not then look at pthread_attr_t

setPbandwidth()

float zyncarla::setPbandwidth

(

int

Pbandwidth

)

Return the BandWidth in cents Get the n-th overtone position relatively to N harmonic.

sfind()

bool zyncarla::sfind	(	std::string	hay,
		std::string	needle )

split()

svec zyncarla::split ( string s )

static

sprng()

void zyncarla::sprng ( prng_t p )

inline

stringFrom()

template<class T>

std::string zyncarla::stringFrom

(

T

x

)

stringTo()

template<class T>

T zyncarla::stringTo

(

const char *

x

)

SubFilterA()

void zyncarla::SubFilterA ( const float coeff[4], float & src, float work[4] )

inline

SubFilterB()

void zyncarla::SubFilterB ( const float coeff[4], float & src, float work[4] )

inline

to_s()

template<class T>

std::string zyncarla::to_s

(

T

x

)

trimLeadingWhite()

const char * zyncarla::trimLeadingWhite

(

const char *

c

)

VelF()

float zyncarla::VelF	(	float	velocity,
		unsigned char	scaling )

version_in_rtosc_fmt()

rtosc_version zyncarla::version_in_rtosc_fmt ( )

static

waveShapeSmps()

void zyncarla::waveShapeSmps	(	int	n,
		float *	smps,
		unsigned char	type,
		unsigned char	drive )

XMLwrapper_whitespace_callback()

const char * zyncarla::XMLwrapper_whitespace_callback	(	mxml_node_t *	node,
		int	where )

Variable Documentation

_ports

const rtosc::Ports zyncarla::_ports

static

adPorts

const Ports zyncarla::adPorts

static

Initial value:

                           = {
    rSelf(ADnoteParameters),
    rPaste,
    rArrayPaste,
    rRecurs(VoicePar, NUM_VOICES),
    {"VoicePar#" STRINGIFY(NUM_VOICES) "/Enabled::T:F",
     rProp(parameter) rShort("enable") rDoc("Voice Enable"),
     NULL, rArrayTCbMember(VoicePar, Enabled)},
    rRecur(GlobalPar, "Adnote Parameters"),
}

AmpEnvelope

EnvelopeParams* zyncarla::AmpEnvelope

AmpLfo

LFOParams* zyncarla::AmpLfo

auto_param_ports

const Ports zyncarla::auto_param_ports

static

automate_ports

const Ports zyncarla::automate_ports

static

bankPorts

const rtosc::Ports zyncarla::bankPorts

block_header_free_bit

const size_t zyncarla::block_header_free_bit = 1 << 0

static

DummyAlloc

DummyAllocator zyncarla::DummyAlloc

eng

EngineMgr* zyncarla::eng = NULL

Fadein_adjustment

unsigned char zyncarla::Fadein_adjustment

FilterEnvelope

EnvelopeParams* zyncarla::FilterEnvelope

FilterLfo

LFOParams* zyncarla::FilterLfo

filterports

rtosc::Ports zyncarla::filterports

static

Initial value:

{
    {"Ptype::i", rProp(parameter) rOptions(Off, LP1, HP1, LP2,
            HP2, BP, notch, peak, l.shelf, h.shelf)
        rShort("type") rDoc("Filter Type"), 0,
        rBegin;
        rEQ(0);
        rEnd},
    {"Pfreq::i", rProp(parameter) rMap(min, 0) rMap(max, 127)
        rShort("freq"), 0,
        rBegin;
        rEQ(1);
        rEnd},
    {"Pgain::i", rProp(parameter) rMap(min, 0) rMap(max, 127)
        rShort("gain"), 0,
        rBegin;
        rEQ(2);
        rEnd},
    {"Pq::i",    rProp(parameter) rMap(min, 0) rMap(max, 127)
        rShort("q") rDoc("Resonance/Bandwidth"), 0,
        rBegin;
        rEQ(3);
        rEnd},
    {"Pstages::i", rProp(parameter) rMap(min, 0) rMap(max, 4)
        rShort("stages") rDoc("Additional filter stages"), 0,
        rBegin;
        rEQ(4);
        rEnd},
}

first

bool zyncarla::first = true

static

FORCE_BANK_DIR_FILE

const char* zyncarla::FORCE_BANK_DIR_FILE = ".bankdir"

FreqEnvelope

EnvelopeParams* zyncarla::FreqEnvelope

FreqLfo

LFOParams* zyncarla::FreqLfo

GlobalFilter

FilterParams* zyncarla::GlobalFilter

globalPorts

const Ports zyncarla::globalPorts

static

in

InMgr* zyncarla::in = NULL

INSTRUMENT_EXTENSION [1/2]

const char* zyncarla::INSTRUMENT_EXTENSION = ".xiz"

static

INSTRUMENT_EXTENSION [2/2]

const char* zyncarla::INSTRUMENT_EXTENSION = ".xiz"

static

isPlugin

bool zyncarla::isPlugin = false

kitPorts

const Ports zyncarla::kitPorts

static

last_update_timestamp

int64_t zyncarla::last_update_timestamp

local_ports

const rtosc::Ports zyncarla::local_ports

static

localPorts

const rtosc::Ports zyncarla::localPorts

static

mapping_ports

const Ports zyncarla::mapping_ports

static

Initial value:

                                 = {
    {"offset::f", rProp(parameter) rDefault(0) rShort("off") rLinear(-50, 50) rMap(unit, percent), 0,
        rBegin;
        int slot = d.idx[1];
        int param = d.idx[0];
        if(!strcmp("f",rtosc_argument_string(msg))) {
            a.setSlotSubOffset(slot, param, rtosc_argument(msg, 0).f);
            a.updateMapping(slot, param);
            d.broadcast(d.loc, "f", a.getSlotSubOffset(slot, param));
        } else
            d.reply(d.loc, "f", a.getSlotSubOffset(slot, param));
        rEnd},
    {"gain::f", rProp(parameter) rDefault(100) rShort("gain") rLinear(-200, 200) rMap(unit, percent), 0,
        rBegin;
        int slot = d.idx[1];
        int param = d.idx[0];
        if(!strcmp("f",rtosc_argument_string(msg))) {
            a.setSlotSubGain(slot, param, rtosc_argument(msg, 0).f);
            a.updateMapping(slot, param);
            d.broadcast(d.loc, "f", a.getSlotSubGain(slot, param));
        } else
            d.reply(d.loc, "f", a.getSlotSubGain(slot, param));
        rEnd},
}

master_ports

const Ports zyncarla::master_ports

static

max_pid_len

std::size_t zyncarla::max_pid_len = 12

constexpr

safe pid lenght guess, posix conform

middlewareReplyPorts

rtosc::Ports zyncarla::middlewareReplyPorts

static

middwareSnoopPorts

rtosc::Ports zyncarla::middwareSnoopPorts

static

msg_id

int zyncarla::msg_id =0

mutex

pthread_mutex_t* zyncarla::mutex = NULL

static

non_realtime_ports [1/2]

const rtosc::Ports zyncarla::non_realtime_ports

static

non_realtime_ports [2/2]

const rtosc::Ports& zyncarla::non_realtime_ports

static

oscilgen

OscilGen* zyncarla::oscilgen

out

OutMgr* zyncarla::out = NULL

PAmpVelocityScaleFunction

unsigned char zyncarla::PAmpVelocityScaleFunction

partPorts

const Ports zyncarla::partPorts

static

PBendAdjust

unsigned char zyncarla::PBendAdjust

PCoarseDetune

unsigned short int zyncarla::PCoarseDetune

PDetune

unsigned short int zyncarla::PDetune

PDetuneType

unsigned char zyncarla::PDetuneType

Pexitprogram

int zyncarla::Pexitprogram = 0

PFilterVelocityScale

unsigned char zyncarla::PFilterVelocityScale

PFilterVelocityScaleFunction

unsigned char zyncarla::PFilterVelocityScaleFunction

PfixedfreqET

unsigned char zyncarla::PfixedfreqET

Parameters for PAD synthesis

Note

unlike most other parameter objects significant portions of this object are `owned' by the non-realtime context. The realtime context only needs the samples generated by the PADsynth algorithm and modulators (ie envelopes/filters/LFOs) for amplitude, frequency, and filters. The ownership will be unclear for the time being, but it should be made more explicit with time. */ class PADnoteParameters:public Presets { public: PADnoteParameters(const SYNTH_T &synth_, FFTwrapper *fft_, const AbsTime *time_ = nullptr); ~PADnoteParameters();

void defaults(); void add2XML(XMLwrapper& xml); void getfromXML(XMLwrapper& xml);

void paste(PADnoteParameters &p); void pasteRT(PADnoteParameters &p);

returns a value between 0.0f-1.0f that represents the estimation perceived bandwidth float getprofile(float *smp, int size);

parameters

the mode: 0 - bandwidth, 1 - discrete (bandwidth=0), 2 - continous the harmonic profile is used only on mode 0 unsigned char Pmode;

Harmonic profile (the frequency distribution of a single harmonic) struct { struct { //base function unsigned char type; unsigned char par1; } base; unsigned char freqmult; //frequency multiplier of the distribution struct { //the modulator of the distribution unsigned char par1; unsigned char freq; } modulator;

unsigned char width; //the width of the resulting function after the modulation struct { //the amplitude multiplier of the harmonic profile unsigned char mode; unsigned char type; unsigned char par1; unsigned char par2; } amp; bool autoscale; //if the scale of the harmonic profile is computed automaticaly unsigned char onehalf; //what part of the base function is used to make the distribution } Php;

 unsigned int  Pbandwidth; //the values are from 0 to 1000
 unsigned char Pbwscale; //how the bandwidth is increased according to the harmonic's frequency

 struct { //where are positioned the harmonics (on integer multimplier or different places)
     unsigned char type;
     unsigned char par1, par2, par3; //0..255
 } Phrpos;

 struct { //quality of the samples (how many samples, the length of them,etc.)
     unsigned char samplesize;
     unsigned char basenote, oct, smpoct;
 } Pquality;

frequency parameters If the base frequency is fixed to 440 Hz unsigned char Pfixedfreq;

/* Equal temperate (this is used only if the Pfixedfreq is enabled) If this parameter is 0, the frequency is fixed (to 440 Hz); if this parameter is 64, 1 MIDI halftone -> 1 frequency halftone

POffsetHz

unsigned char zyncarla::POffsetHz

ports [1/2]

const rtosc::Ports zyncarla::ports

static

ports [2/2]

const rtosc::MergePorts zyncarla::ports

static

postfix

string zyncarla::postfix

PPanning

unsigned char zyncarla::PPanning

PPunchStrength

unsigned char zyncarla::PPunchStrength

PPunchStretch

unsigned char zyncarla::PPunchStretch

PPunchTime

unsigned char zyncarla::PPunchTime

PPunchVelocitySensing

unsigned char zyncarla::PPunchVelocitySensing

preset_ports

const rtosc::Ports zyncarla::preset_ports

Initial value:

{
    {"scan-for-presets:", rDoc("Scan For Presets"), 0, dummy},
    {"copy:s:ss:si:ssi",  rDoc("Copy (s)URL to (s) Name/Clipboard from subfield (i)"), 0, dummy},
    {"paste:s:ss:si:ssi", rDoc("Paste (s) URL to (s) File-Name/Clipboard from subfield (i)"), 0, dummy},
    {"clipboard-type:",   rDoc("Type Stored In Clipboard"), 0, dummy},
    {"delete:s", rDoc("Delete the given preset file"), 0, dummy},
}

prng_state

prng_t zyncarla::prng_state = 0x1234

PStereo

unsigned char zyncarla::PStereo

PVolume

unsigned char zyncarla::PVolume

real_preset_ports

const rtosc::Ports zyncarla::real_preset_ports

realtime_ports [1/2]

const rtosc::Ports zyncarla::realtime_ports

static

realtime_ports [2/2]

const rtosc::Ports& zyncarla::realtime_ports

static

resonance

Resonance* zyncarla::resonance

sample

Sample zyncarla::sample[PAD_MAX_SAMPLES]

RT sample data.

sizeof_pvowels

int zyncarla::sizeof_pvowels = sizeof(FilterParams::Pvowels)

constexpr

slot_ports

const Ports zyncarla::slot_ports

static

SUBnotePorts

const rtosc::Ports zyncarla::SUBnotePorts

static

subports

const rtosc::Ports zyncarla::subports

static

Initial value:

                                   = {
    {"Pformants#" STRINGIFY(FF_MAX_FORMANTS) "/", NULL, &subsubports,
        [](const char *msg, RtData &d) {
            const char *mm = msg;
            while(*mm && !isdigit(*mm)) ++mm;
            unsigned idx = atoi(mm);
 
            SNIP;
            FilterParams::Pvowels_t *obj = (FilterParams::Pvowels_t *) d.obj;
            d.obj = (void*) &obj->formants[idx];
            subsubports.dispatch(msg, d);
        }},
}

subsubports

const rtosc::Ports zyncarla::subsubports

static

Initial value:

                                      = {
    rParamZyn(freq, rShort("f.freq"), "Formant frequency"),
    rParamZyn(amp,  rShort("f.str"),  "Strength of formant"),
    rParamZyn(q,    rShort("f.q"),    "The formant's quality factor, also known as resonance bandwidth or Q for short"),
}

synth

const SYNTH_T& zyncarla::synth

sysefsendto

const Ports zyncarla::sysefsendto

static

Initial value:

                               =
{
    {"to#" STRINGIFY(NUM_SYS_EFX) "::i",
        rProp(parameter) rDoc("sysefx to sysefx routing gain"), 0, [](const char *m, RtData&d)
        {
            
            
            const char* m_findslash = m + strlen(m),
                      * loc_findslash = d.loc + strlen(d.loc);
            for(;*loc_findslash != '/'; --m_findslash, --loc_findslash)
                assert(*loc_findslash == *m_findslash);
            assert(m_findslash + 1 == m);
 
            const char *index_1 = loc_findslash-1;
            assert(isdigit(*index_1));
            if(isdigit(index_1[-1]))
                index_1--;
            int ind1 = atoi(index_1);
 
            
            while(!isdigit(*m)) m++;
            int ind2 = atoi(m);
            Master &master = *(Master*)d.obj;
 
            if(rtosc_narguments(m))
                master.setPsysefxsend(ind1, ind2, rtosc_argument(m,0).i);
            else
                d.reply(d.loc, "i", master.Psysefxsend[ind1][ind2]);
        }}
}

sysefxPort

const Ports zyncarla::sysefxPort

static

time

const AbsTime* zyncarla::time

verbose

bool zyncarla::verbose = false

version

version_type zyncarla::version

constexpr

the current zynaddsubfx version

voicePorts

const Ports zyncarla::voicePorts

static

watchPorts

const Ports zyncarla::watchPorts

static

Initial value:

                              = {
    {"add:s", rDoc("Add synthesis state to watch"), 0,
        rBegin;
        m->watcher.add_watch(rtosc_argument(msg,0).s);
        rEnd},
}

xml_k

int zyncarla::xml_k = 0