Namespace Ase

Namespace List > Ase

The Anklang C++ API namespace. More...

Namespaces

Type	Name
namespace	AnsiColors The AnsiColors namespace contains utility functions for colored terminal output.
namespace	Aux Auxillary algorithms brodly useful.
namespace	DBus
namespace	FastMemory Utilities for allocating cache line aligned memory from huge pages.
namespace	Impl
namespace	Lib
namespace	Loft Loft - A special purpose memory allocator for lock- and obstruction-free thread progress.
namespace	MakeIcon
namespace	MidiLib Namespace used for Midi Processor implementations.
namespace	Path The Path namespace provides functions for file path manipulation and testing.
namespace	SortingNetworks
namespace	Test Helper namespace for unit testing.
namespace	Unicode

Classes

Type	Name
struct	AlignedPOD <SIZE>
class	AsyncBlockingQueue <class Value> This is a thread-safe asyncronous queue which blocks in pop() until data is provided through push().
class	AtomicBits Vector of atomic bits, operates in blocks of 64 bits.
class	AtomicIntrusiveStack <class T>
struct	AtomicStack <typename Value, GrowOnlyAllocator>
class	AudioChain
class	AudioCombo
class	AudioEngine
class	AudioEngineThread
struct	AudioParams Audio parameter handling, internal to AudioProcessor .
class	AudioProcessor Audio signal AudioProcessor base class, implemented by all effects and instruments.
struct	AudioProcessorInfo Detailed information and common properties of AudioProcessor subclasses.
struct	AudioProcessorRegistry
class	AudioPropertyImpl
struct	AudioTransport Transport information for AudioSignal processing.
class	AutoSeeder AutoSeeder provides non-deterministic seeding entropy.
class	Blob Binary large object storage container.
class	BlobImpl
struct	BusInfo Structure providing supplementary information about input/output buses.
class	ByteBlob <class Deleter>
struct	CPUInfo Acquire information about the runtime architecture and CPU type.
class	CString Compact, deduplicating string variant for constant strings.
class	CStringTable Map std::string <-> uint IDs, thread safe.
class	CallbackList <A> Reentrant callback list with configurable arguments.
struct	Choice Representation of one possible choice for selection properties.
class	ClapAudioProcessor
class	ClapDeviceImpl
class	ClapFileHandle
struct	ClapParamInfo
struct	ClapParamInfoImpl
struct	ClapParamUpdate
class	ClapPluginDescriptor
class	ClapPluginHandle
class	ClapPluginHandleImpl
struct	ClapPropertyImpl
class	Clip Container for MIDI note and control events.
class	ClipImpl
struct	ClipNote Part specific note event representation.
class	CoalesceNotifies
struct	ConvertJsTrigger Convert between Jsonipc::JsonValue to JsTrigger .
struct	ConvertValue Convert between Value and Jsonipc::JsonValue.
struct	ConvertValueP Convert between ValueP and Jsonipc::JsonValue.
struct	ConvertValueR Convert between ValueR and Jsonipc::JsonValue.
struct	ConvertValueRP Convert between std::shared_ptr<ValueR> and Jsonipc::JsonValue.
class	CustomDataContainer
class	CustomDataKey <typename T> CustomDataKey objects are used to identify and manage custom data members ofCustomDataContainer objects.
struct	CustomServerConfig
class	Device Interface to access Device instances.
class	DeviceImpl
struct	DeviceInfo Info for device types.
class	DispatcherSource EventLoop source for handler execution.
class	Driver Base class for a PCM and MIDI devices.
struct	DriverEntry Driver information for PCM and MIDI handling.
struct	DriverSet
class	Emittable Base type for classes with Event subscription.
class	EmittableImpl Implementation type for classes with Event subscription.
struct	EngineJobImpl
class	EngineMidiInput
struct	EnumInfo Get auxiallary enum information.
struct	Event Structure for callback based notifications.
class	EventConnection
class	EventFd Wakeup facility for IPC.
class	EventList <class Event, class Compare> Maintain an array of unique Event structures with change notification.
class	EventLoop Loop object, polling for events and executing callbacks in accordance.
class	EventSource EventLoop source for callback execution.
class	FastMemArray <typename T, ALIGNMENT> Array with cache-line-alignment containing a fixed numer of PODs.
class	FileCrawler Class implementing a file system crawler.
class	FileStreamWriter
class	FlacWriter
class	Gadget Base type for classes that have a Property .
struct	GadgetClassMemberList
class	GadgetImpl Base type for classes that have a Property .
struct	Gtk2DlWrapEntry
struct	Gtk2WindowSetup
struct	Has_serialize_f <class, class> Has_serialize_f<T> - Check if serialize(T&, WritNode &) is provided forT .
struct	Has_serialize_f< T, void_t< decltype(serialize(std::declval< T & >(), std::declval< WritNode & >())) > > <class T>
struct	IconString
struct	Id32 Helper class for integer IDs up to 32 Bit, possibly of enum type.
class	IniFile Class to parse INI configuration file sections and values.
class	IniWriter Class to write INI configuration file sections and values.
struct	JobQueue
class	JsTrigger Callback mechanism for Jsonapi/Jsonipc.
class	JsonapiConnection
class	KeccakCryptoRng
class	KeccakFastRng
class	KeccakGoodRng
class	KeccakRng
struct	L2DMatrix <typename T>
struct	LocalResourceEntry
struct	LoftConfig Configuration for Loft allocations.
struct	LoftFree A std::unique_ptr<> deleter for Loft allocations.
struct	LoftStats Statistics for Loft allocations.
struct	LogFormat Wrap a string together with its source code location.
struct	Logscale Logarithmically map (and invert) a range onto 0…+1.
struct	LoopState
struct	MainApp
struct	MainAppImpl
class	MainLoop An EventLoop implementation that offers public API for running the loop.
class	Member <setter, getter> Implement C++ member field API with a 0-sized class from setter and getter, maybe combined with [[no_unique_address]] .
class	Member< accessor, nullptr > <accessor> Member accessor class based on a single accessor, maybe combined with[[no_unique_address]] .
struct	MemberAccessor
struct	MemberDetails
class	MidiDriver Base class for a MIDI devices.
struct	MidiEvent MidiEvent data structure.
class	MidiEventOutput A stream of writable MidiEvent structures.
class	MidiEventReader <MAXQUEUES> An in-order MidiEvent reader for multipleMidiEvent sources.
struct	MidiNote Components of a MIDI note.
class	Monitor Interface for monitoring output signals.
class	MonitorImpl
struct	MpmcStack <typename Node>
struct	Mutable <class T> Helper to modify const struct contents, e.g. asyn job lambda members.
class	Mwc256 Marsaglia multiply-with-carry generator, period ca 2^255.
class	NativeDevice Interface to access NativeDevice instances.
class	NativeDeviceImpl
struct	NoDelete
class	NullMidiDriver
class	NullPcmDriver
class	Object Base type for classes with Property interfaces.
class	ObjectImpl Implementation type for classes with Property interfaces.
class	OpusWriter
struct	OrderedEventList <class Event, class CompareOrder> Container for a sorted array of opaque Event structures with binary lookup.
struct	Param Structured initializer for Parameter .
struct	ParamExtraVals Helper to specify parameter ranges.
struct	Parameter Structure to provide information about properties or preferences.
struct	ParameterMap Parameter list construction helper.
class	ParameterProperty Abstract base type for Property implementations withParameter meta data.
struct	PcRe2
class	Pcg32Rng
class	PcmDriver Base class for a PCM devices.
struct	PcmDriverConfig PCM device configuration.
class	Persistent <class Class>
struct	PollFD Mirrors struct pollfd for poll(3posix)
class	PollFDSource EventLoop source for IO callbacks.
class	Preference Class for preference parameters (global settings)
struct	PrefsValue
struct	ProbeFeatures Bits representing a selection of probe sample data features.
class	ProcessorManager Interface for management, connecting and processing of AudioProcessor instances.
class	Project Projects support loading, saving, playback and act as containers for all other sound objects.
class	ProjectImpl
class	Property A Property allows querying, setting and monitoring of an object property.
class	PropertyImpl Property implementation forGadgetImpl , using lambdas as accessors.
struct	PwdUser
struct	QueueMultiplexer <MAXQUEUES, class ForwardIterator>
class	QuickArray <class Data>
struct	QuickSourcePArray
class	Re Wrapper for std::regex to simplify usage and reduce compilation time.
struct	RegisteredDriver <typename DriverP>
struct	RegisteredLoader
struct	Resource Description of a resource, possibly nested.
class	ResourceCrawler Helper to crawl hierarchical resources.
struct	RtCall Wrap simple callback pointers, without using malloc (obstruction free).
struct	RtCallJob
struct	RtJobQueue Add a simple callback to the main event loop, without using malloc (obstruction free).
struct	SHA3_224
struct	SHA3_256
struct	SHA3_384
struct	SHA3_512
struct	SHAKE128
struct	SHAKE256
class	SHAKE_Base <HASHBITS, DOMAINBITS>
class	ScopedPosixLocale Class to push the POSIX/C locale_t (UTF-8) for the scope of its lifetime.
class	ScopedSemaphore
class	Serializable Interface for serializable objects with Reflink support.
class	Server Central singleton, serves as API entry point.
class	ServerImpl
class	SharedBase Common base type for polymorphic classes managed by std::shared_ptr<> .
class	SortedVector <class T, class Less> Vector that keeps its elements sorted.
class	Stopwatch
class	Storage
class	StorageReader
class	StorageWriter
class	StreamReader
class	StreamReaderFile
class	StreamReaderZStd
class	StreamReaderZipMember
class	StreamWriter
class	StreamWriterZStd
class	StringBlob
class	Strings Convenience Constructor for StringSeq or std::vector<std::string>
class	SubLoop
class	TaskRegistry The task registry keeps track of runtime threads for profiling and statistical purposes.
struct	TaskStatus Acquire information about a task (process or thread) at runtime.
struct	TelemetryField Telemetry segment location.
class	TelemetryPlan
struct	TelemetrySegment Telemetry segment location.
struct	TickSignature Musical time signature and tick conversions.
class	TimedSource EventLoop source for timer execution.
class	Track Container for Clip objects and sequencing information.
class	TrackImpl Ase::Track implementation.
struct	TransportLimits
class	USignalSource EventLoop source for handler execution.
class	UndoScope
struct	UserNote Contents of user interface notifications.
struct	Value Value type used to interface with various property types.
struct	ValueField
struct	ValueR
struct	ValueS
struct	VirtualBase Common base type to allow casting between polymorphic classes.
class	WavWriterImpl
class	WaveWriter
class	WebSocketConnection
class	WebSocketServer
struct	WebSocketServerImpl
class	Writ Document containing all information needed to serialize and deserialize a Value .
struct	WritConverter <typename T, typename> Template to specialize string conversion for various data types.
struct	WritConverter< T, REQUIRESv< !std::is_base_of< Serializable, T >::value &&!Jsonipc::DerivesVector< T >::value &&!Jsonipc::DerivesSharedPtr< T >::value &&std::is_class< T >::value > > <typename T>
struct	WritConverter< T, REQUIRESv< std::is_base_of< Serializable, T >::value > > <typename T>
struct	WritConverter< T, REQUIRESv< std::is_enum< T >::value > > <typename T>
struct	WritConverter< T, REQUIRESv< std::is_integral< T >::value||std::is_floating_point< T >::value > > <typename T>
class	WritLink
class	WritNode One entry in a Writ serialization document.

Public Types

Type	Name
enum	Ase
union	ClapEventUnion
union	FloatIEEE754
typedef boost::atomic< T >	Atomic Substitute for std::atomic<> with fixes for GCC.
typedef std::atomic< uint64 >	AtomicU64
typedef std::vector< CString >	CStringS
enum	CacheType
typedef std::vector< std::function< void()> >	CallbackS
typedef std::function< ChoiceS(const CString &)>	ChoicesFunc Handler to generate all possible parameter choices dynamically.
typedef std::vector< clap_event_param_value >	ClapEventParamS
typedef std::vector< ClapEventUnion >	ClapEventUnionS
typedef std::tuple< clap_id, double >	ClapParamIdValue
typedef std::vector< ClapParamIdValue >	ClapParamIdValueS
typedef std::unordered_map< clap_id, ClapParamInfoImpl * >	ClapParamInfoMap
typedef std::vector< ClapParamInfo >	ClapParamInfoS
typedef std::vector< ClapParamUpdate >	ClapParamUpdateS
typedef std::tuple< clap_id, String >	ClapResourceHash
typedef std::vector< ClapResourceHash >	ClapResourceHashS
typedef std::vector< ClipImpl::Generator >	ClipImplGeneratorS
typedef std::vector< std::function< void(double)> >	DCallbackS
typedef std::shared_ptr< DispatcherSource >	DispatcherSourceP
typedef Driver::DriverP	DriverP
enum int32_t	Error Enum representing Error states.
typedef std::shared_ptr< EventConnection >	EventConnectionP
typedef std::weak_ptr< EventConnection >	EventConnectionW
typedef std::function< void(const Event &)>	EventHandler
typedef std::shared_ptr< EventLoop >	EventLoopP
typedef std::shared_ptr< EventSource >	EventSourceP
typedef Mwc256	FastRng
enum uint16	IBusId ID type for AudioProcessor input buses, buses are numbered with increasing index.
typedef typename ::std::enable_if< I==J, bool >::type	IDX
typedef std::shared_ptr< SharedBase >	InstanceP
typedef std::function< bool(const String &)>	JsonapiBinarySender
typedef std::shared_ptr< JsonapiConnection >	JsonapiConnectionP
typedef std::weak_ptr< JsonapiConnection >	JsonapiConnectionW
typedef std::unique_ptr< T, LoftFree >	LoftPtr A std::unique_ptr<> for Loft allocations.
enum	LogFlags Flags to configure logging behaviour.
typedef std::shared_ptr< MainLoop >	MainLoopP
typedef MidiDriver::MidiDriverP	MidiDriverP
enum uint8_t	MidiEventType Type of MIDI Events.
enum int32_t	MidiMessage Extended type information for MidiEvent .
typedef std::tuple< double, double, double >	MinMaxStep Min, max, stepping for double ranges.
typedef std::shared_ptr< MonitorImpl >	MonitorImplP
enum uint8	MusicalTuning Musical tunings, see: http://en.wikipedia.org/wiki/Musical_tuning .
enum uint16	OBusId ID type for AudioProcessor output buses, buses are numbered with increasing index.
typedef std::shared_ptr< ObjectImpl >	ObjectImplP
enum uint32	ParamId ID type for AudioProcessor parameters, the ID numbers are user assignable.
typedef std::variant< bool, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, const char *, std::string >	ParamInitialVal Initial value for parameters.
typedef std::shared_ptr< const Parameter >	ParameterC
typedef PcmDriver::PcmDriverP	PcmDriverP
typedef std::shared_ptr< PollFDSource >	PollFDSourceP
typedef std::unordered_map< CString, PrefsValue >	PrefsMap
typedef CallbackList< CString, const Value & >	PrefsValueCallbackList
typedef std::shared_ptr< ProjectImpl >	ProjectImplP
typedef std::function< void(Value &)>	PropertyGetter Function type for Property value getters.
typedef std::function< ChoiceS(const ParameterProperty &)>	PropertyLister Function type to list Choice __Property values.
typedef std::function< bool(const Value &)>	PropertySetter Function type for Property value setters.
typedef typename ::std::enable_if< value, bool >::type	REQUIRES REQUIRES<value> - Simplified version of std::enable_if<cond,bool>::type to use SFINAE in function templates.
typedef typename ::std::enable_if< value, void >::type	REQUIRESv REQUIRESv<value> - Simplified version of std::enable_if<cond,void>::type to use SFINAE in struct templates.
enum	RPath
typedef Error(*)()	RegisteredLoaderFunc
typedef std::vector< RegisteredLoader >	RegisteredLoaderVector
enum	ResourceType
enum uint64_t	SpeakerArrangement
typedef AsyncBlockingQueue< char >	StartQueue
typedef std::string	String Convenience alias for std::string.
typedef std::tuple< String, String, String >	String3
typedef std::pair< std::string, std::string >	StringPair
typedef std::vector< std::tuple< String, String > >	StringPairS
typedef std::vector< String >	StringS Convenience alias for a std::vector<std::string>.
typedef typename ::std::enable_if< std::is_same< T, C >::value, bool >::type	TYP
typedef std::id	ThreadId
typedef std::shared_ptr< TimedSource >	TimedSourceP
typedef std::shared_ptr< USignalSource >	USignalSourceP
typedef std::shared_ptr< Value >	ValueP
typedef std::variant< std::monostate, bool, int64, double, String, ValueS, ValueR, InstanceP >	ValueVariant Variant type to hold different types of values.
typedef std::shared_ptr< VirtualBase >	VirtualBaseP
typedef std::function< void()>	VoidF
typedef std::function< void()>	VoidFunc
typedef std::shared_ptr< WaveWriter >	WaveWriterP
typedef std::shared_ptr< WebSocketConnection >	WebSocketConnectionP
typedef std::shared_ptr< WebSocketServerImpl >	WebSocketServerImplP
typedef std::shared_ptr< WebSocketServer >	WebSocketServerP
typedef WppConnectionP::element_type	WppConnection
typedef WppServer::connection_ptr	WppConnectionP
typedef websocketpp::connection_hdl	WppHdl
typedef websocketpp::server< CustomServerConfig >	WppServer
typedef std::vector< WritNode >	WritNodeS
typedef std::shared_ptr< Writ >	WritP
typedef int16_t	int16 A 16-bit signed integer.
typedef int32_t	int32 A 32-bit signed integer.
typedef int64_t	int64 A 64-bit unsigned integer, use PRI*64 in format strings.
typedef int8_t	int8 An 8-bit signed integer.
typedef uint32_t	uint Provide 'uint' as convenience type.
typedef uint16_t	uint16 A 16-bit unsigned integer.
typedef uint32_t	uint32 A 32-bit unsigned integer.
typedef uint64_t	uint64 A 64-bit unsigned integer, use PRI*64 in format strings.
typedef uint8_t	uint8 An 8-bit unsigned integer.
typedef uint32_t	unichar A 32-bit unsigned integer used for Unicode characters.

Public Attributes

Type	Name
constexpr const uint	AUDIO_BLOCK_FLOAT_ZEROS_SIZE = 16384 Maximum number of values in the const_float_zeros block.
const MainApp &	App = main\_app
constexpr const double	DOUBLE_EPSILON = 1.1102230246251565404236316680908203125e-16 Double round-off error at 1.0, equals 2^-53.
constexpr const uint	FIXED_N_CHANNELS = 2
constexpr const uint	FIXED_N_MIDI_DRIVERS = 4
constexpr const uint	FIXED_SAMPLE_RATE = 48000
constexpr const char	GUIONLY = ":G:r:w:" GUI READABLE WRITABLE.
constexpr double	INVERSE_SEMIQUAVER = 1.0 / SEMIQUAVER\_TICKS
constexpr const int64	MAX_BPM = 1776
constexpr const int64	MAX_SAMPLERATE = 192000
constexpr const uint	MIDI_NOTE_ID_FIRST = 0x10000001 First (internal) MIDI note event ID (lower IDs are reserved for external notes).
constexpr const uint	MIDI_NOTE_ID_LAST = 0xfffffffe Last valid (internal) MIDI note event ID.
constexpr const int64	MIN_BPM = 10
constexpr const int64	MIN_SAMPLERATE = 8000
constexpr const int64	SEMIQUAVER_TICKS = [**TRANSPORT\_PPQN**](namespaceAse.md#variable-transport_ppqn) / 4
ServerImpl *	SERVER = nullptr
constexpr const char	STANDARD = ":S:G:r:w:" STORAGE GUI READABLE WRITABLE.
constexpr const char	STORAGE = ":S:r:w:" STORAGE READABLE WRITABLE.
constexpr const int64	TRANSPORT_PPQN = 4838400 Maximum number of sample frames to calculate in Processor::render().
constexpr const bool	__DEV__ = false
void	__noreturn__
Ts &&	args = /* multi line expression */
bool	ase_debugging_enabled = true Global boolean to reduce debugging penalty where possible.
bool	ase_fatal_warnings = false Global boolean to cause the program to abort on warnings.
const char *const	ase_gettext_domain
const int	ase_major_version
const int	ase_micro_version
const int	ase_minor_version
const char *const	ase_sharedir
const char *const	ase_version_long
const char *const	ase_version_short
bool	assertion_failed_fatal = false Global flag to force aborting on assertion warnings.
uint64_t	cached_hash_secret = 0 Use hash_secret() for access.
const float *const	cent_table = cent\_table201 + 100 Finetune factor table with 201 entries for -100…0…+100 cent.
uint64_t	columnline
float	const_float_zeros = { 0, } Block of const floats allof value 0.
bool const char *	fileglob
uint64_t const char const char *	format
uint64_t const char *	func
size_t	level
MainAppImpl	main_app
JobQueue	main_jobs Execute a job callback in the Ase main loop.
MainLoopP	main_loop
RtJobQueue	main_rt_jobs Queue a callback for the main_loop without invoking malloc(), addition is obstruction free.
bool const char const size_t	maxbytes = /* multi line expression */
const float *const	semitone_tables_265 = /* multi line expression */ Musical Tuning Tables, to be indexed by MusicalTuning __
size_t	size
constexpr SpeakerArrangement	speaker_arrangement_channels_mask = { ~size\_t (SpeakerArrangement::AUX) }
constexpr uint32_t	unicode_last_codepoint = 0x10FFFF

Public Static Attributes

Type	Name
constexpr int64_t	AUDIO_BLOCK_MAX_RENDER_SIZE = 2048
constexpr double	D64MAX = 1.7976931348623157e+308
constexpr float	F32EPS = 5.9604644775390625e-08
constexpr float	F32MAX = 3.40282347e+38
constexpr int32_t	I31MAX = +2147483647
constexpr int32_t	I31MIN = -2147483648
constexpr int64_t	I63MAX = +9223372036854775807
constexpr int64_t	I63MIN = -9223372036854775807 - 1
constexpr const uint8_t	KECCAK_RHO_OFFSETS = /* multi line expression */
constexpr const uint64_t	KECCAK_ROUND_CONSTANTS
constexpr float	M23MAX = 16777216
constexpr double	M52MAX = 9007199254740992
constexpr const uint	MAX_LAUNCHER_CLIPS = 8
constexpr const size_t	MB = 1024 \* 1024
constexpr OBusId	OUT1 = [**OBusId**](namespaceAse.md#enum-obusid) (1)
constexpr bool	PRINT_ADAPTIVE = false
constexpr uint32_t	U32MAX = +4294967295u
constexpr uint64_t	U64MAX = +18446744073709551615ull
const int16	UNDEFINED_PRIORITY = -32768
std::vector< ProjectImplP > &	all_projects = \*new std::vector&lt;ProjectImplP&gt;()
bool	arg_class_tree = false
bool	arg_js_api = false
const char *const	ase_linkid = "\u0012.ID"
std::vector< std::function< void()> * >	atquit_funcs
std::mutex	atquit_mutex
std::atomic< uint8_t >	atquit_triggered_ = false
const auto	audio_chain_id = [**register\_audio\_processor**](namespaceAse.md#function-register_audio_processor)&lt;AudioChain&gt;()
std::id	audio_engine_thread_id = {}
constexpr const long double	c3_hertz = 261.6255653005986346778499935233
constexpr const long double	c3_hertz_inv = 0.0038222564329714297410505703465146
String	cached_application_name
String	cached_program_alias
std::vector< String >	cachedirs_list
std::mutex	cachedirs_mutex
const float	cent_table201
StringS	check_test_names
CString	clap_audio_wrapper_aseid = [**register\_audio\_processor**](namespaceAse.md#function-register_audio_processor)&lt;ClapAudioProcessor&gt;()
CoalesceNotifies *	coalesce_notifies_head = nullptr
jmp_buf	cpu_info_jmp_buf
CString	cstring_early_test = "NULL"
JsonapiConnectionP	current_message_conection
int	embedding_fd = -1
const MidiEventOutput	empty_event_output
std::atomic< AudioProcessor * >	enotify_queue_head = { enotify\_queue\_tail }
AudioProcessor *const	enotify_queue_tail = ([**AudioProcessor**](classAse_1_1AudioProcessor.md)\*) ptrdiff\_t (-1)
std::vector< std::pair< const std::type_info *, std::function< EnumInfo(int64)> > >	enuminfo_funcs
std::mutex	enuminfo_mutex
CustomDataKey< String >	gadget_name_key
volatile int	global_id_counter = 65536
const clap_host_audio_ports	host_ext_audio_ports = /* multi line expression */
const clap_host_file_reference	host_ext_file_reference = /* multi line expression */
const clap_host_gui	host_ext_gui = /* multi line expression */
const clap_host_log	host_ext_log = { .[**log**](namespaceAse.md#function-log) = host\_log }
const clap_host_params	host_ext_params = /* multi line expression */
const clap_host_posix_fd_support	host_ext_posix_fd_support = /* multi line expression */
const clap_host_thread_check	host_ext_thread_check = /* multi line expression */
const clap_host_timer_support	host_ext_timer_support = /* multi line expression */
constexpr int	jsbin_logflags = 1 \| 256
constexpr int	jsipc_logflags = 1 \| 2 \| 4 \| 8 \| 16
size_t	last_loft_preallocation = 0
std::atomic< bool >	loft_needs_preallocation_mt = false
bool	log_colorize = true
int	log_fd = -1
uint32_t	log_flags = 0
AtomicIntrusiveStack< RtCallJob >	main_rt_jobs_
Preference	midi1_driver_pref = /* multi line expression */
Preference	midi2_driver_pref = /* multi line expression */
Preference	midi3_driver_pref = /* multi line expression */
Preference	midi4_driver_pref = /* multi line expression */
clockid_t	monotonic_clockid = CLOCK\_REALTIME
uint64	monotonic_resolution = 1000
uint64	monotonic_start = 0
bool	musical_tuning_info__ = EnumInfo::impl (musical\_tuning\_info)
constexpr uint	mwc256_MP_SIZE = 5
uint64_t	mwc256_mod = { 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, Mwc256::MWC\_A3 - 1 }
std::atomic< uint >	next_noteid = { [**MIDI\_NOTE\_ID\_FIRST**](namespaceAse.md#variable-midi_note_id_first) }
CStringS	notify_preference_queue
const String	null_midi_driverid = MidiDriver::register\_driver ("null", NullMidiDriver::create, NullMidiDriver::list\_drivers)
const String	null_pcm_driverid = PcmDriver::register\_driver ("null", NullPcmDriver::create, NullPcmDriver::list\_drivers)
Preference	pcm_driver_pref = /* multi line expression */
bool	preferences_autosave = false
std::shared_ptr< CallbackList< CStringS > >	prefs_callbacks = [**CallbackList**](classAse_1_1CallbackList.md)&lt;CStringS&gt;::make\_shared()
uint64	programstart_timestamp = [**timestamp\_now**](namespaceAse.md#function-timestamp_now)()
uint64	realtime_start = 0
bool	registered_loaders_executed = false
std::atomic< const AudioProcessorRegistry * >	registry_first
float	scratch_float_buffer
std::atomic< bool >	seen_autostop = false
const float	semitone_table265_diatonic_scale = /* multi line expression */
const float	semitone_table265_equal_temperament_12_tet = /* multi line expression */
const float	semitone_table265_equal_temperament_5_tet = /* multi line expression */
const float	semitone_table265_equal_temperament_7_tet = /* multi line expression */
const float	semitone_table265_indian_scale = /* multi line expression */
const float	semitone_table265_kirnberger_temperament = /* multi line expression */
const float	semitone_table265_pentatonic_5_limit = /* multi line expression */
const float	semitone_table265_pentatonic_blues = /* multi line expression */
const float	semitone_table265_pentatonic_gogo = /* multi line expression */
const float	semitone_table265_pythagorean_tuning = /* multi line expression */
const float	semitone_table265_quarter_comma_meantone = /* multi line expression */
const float	semitone_table265_silbermann_sorge_temperament = /* multi line expression */
const float	semitone_table265_werckmeister3_temperament = /* multi line expression */
const float	semitone_table265_werckmeister4_temperament = /* multi line expression */
const float	semitone_table265_werckmeister5_temperament = /* multi line expression */
const float	semitone_table265_werckmeister6_temperament = /* multi line expression */
const float	semitone_table265_young_temperament = /* multi line expression */
String	subprotocol_authentication
Preference	synth_latency_pref = /* multi line expression */
Preference	synth_latency_pref = /* multi line expression */
std::mutex	task_registry_mutex_
TaskRegistry::List	task_registry_tasks_
CustomDataKey< TelemetryPlanP >	telemetry_key
constexpr size_t	telemetry_size = 4 \* 1024 \* 1024
uint	timerid_maybe_save_preferences = 0
std::atomic< uint >	user_note_id = 1
std::atomic< uint32 >	usignals_notified = { 0, 0, 0, 0, 0, 0, 0, 0 }
const char *	whitespaces = " \t\v\f\n\r"
Gtk2DlWrapEntry *	x11wrapper = nullptr
struct Ase	zstd_adaptive_level = /* multi line expression */

Public Functions

Type	Name
	ASE_CLASS_DECLS (ClapAudioProcessor)
	ASE_CLASS_DECLS (ClapPluginHandleImpl)
	ASE_CLASS_DECLS (AudioChain)
	ASE_CLASS_DECLS (AudioCombo)
	ASE_CLASS_DECLS (AudioEngineThread)
	ASE_CLASS_DECLS (AudioProcessor)
	ASE_CLASS_DECLS (ClapDeviceImpl)
	ASE_CLASS_DECLS (ClapPluginHandle)
	ASE_CLASS_DECLS (Clip)
	ASE_CLASS_DECLS (ClipImpl)
	ASE_CLASS_DECLS (Device)
	ASE_CLASS_DECLS (DeviceImpl)
	ASE_CLASS_DECLS (Emittable)
	ASE_CLASS_DECLS (FileCrawler)
	ASE_CLASS_DECLS (Gadget)
	ASE_CLASS_DECLS (GadgetImpl)
	ASE_CLASS_DECLS (Monitor)
	ASE_CLASS_DECLS (NativeDevice)
	ASE_CLASS_DECLS (NativeDeviceImpl)
	ASE_CLASS_DECLS (Object)
	ASE_CLASS_DECLS (Preference)
	ASE_CLASS_DECLS (Project)
	ASE_CLASS_DECLS (ProjectImpl)
	ASE_CLASS_DECLS (Property)
	ASE_CLASS_DECLS (PropertyImpl)
	ASE_CLASS_DECLS (ResourceCrawler)
	ASE_CLASS_DECLS (Server)
	ASE_CLASS_DECLS (ServerImpl)
	ASE_CLASS_DECLS (SharedBase)
	ASE_CLASS_DECLS (StreamReader)
	ASE_CLASS_DECLS (StreamWriter)
	ASE_CLASS_DECLS (Track)
	ASE_CLASS_DECLS (TrackImpl)
	ASE_CLASS_DECLS (Driver)
	ASE_CLASS_DECLS (MidiDriver)
	ASE_CLASS_DECLS (PcmDriver)
	ASE_CLASS_DECLS (EngineMidiInput)
	ASE_CLASS_DECLS (TelemetryPlan)
	ASE_DEFINE_ENUM_EQUALITY (Error)
	ASE_DEFINE_ENUM_EQUALITY (MusicalTuning)
	ASE_DEFINE_ENUM_EQUALITY (ParamId)
	ASE_DEFINE_ENUM_EQUALITY (IBusId)
	ASE_DEFINE_ENUM_EQUALITY (OBusId)
	ASE_STRUCT_DECLS (AudioProcessorInfo)
	ASE_STRUCT_DECLS (Choice)
	ASE_STRUCT_DECLS (ClapParamUpdate)
	ASE_STRUCT_DECLS (ClipNote)
	ASE_STRUCT_DECLS (DeviceInfo)
	ASE_STRUCT_DECLS (DriverEntry)
	ASE_STRUCT_DECLS (Parameter)
	ASE_STRUCT_DECLS (Resource)
	ASE_STRUCT_DECLS (TelemetryField)
	ASE_STRUCT_DECLS (TelemetrySegment)
	ASE_STRUCT_DECLS (UserNote)
int	QueueMultiplexer_priority (const MidiEvent & e)
const char *()	_ (const char * string) Translate message strings in the Anklang/ASE text domain.
std::string()	_ (const std::string & string) Translate message strings in the Anklang/ASE text domain.
const char *()	_ (const char * string, const char * plural, int64_t n) Translate message strings in the Anklang/ASE text domain, use @plural forms if != 1.
std::string()	_ (const std::string & string, const std::string & plural, int64_t n) Translate message strings in the Anklang/ASE text domain, use @plural forms if != 1.
	__attribute__ ((always_inline)) Call inplace new operator by automatically inferring the Type.
	__attribute__ ((always_inline)) Call inplace delete operator by automatically inferring the Type.
	__attribute__ ((noinline))
	__attribute__ ((__noinline__)) const
	__attribute__ ((__always_inline__)) const
const char *()	__format_arg__ (2)
void	anklang_cachedir_clean_stale () Clean stale cache directories from past runtimes, may be called from any thread.
void	anklang_cachedir_cleanup (const String & cachedir) Cleanup a cachedir previously created with anklang_cachedir_create() .
String	anklang_cachedir_create () Create exclusive cache directory for this process' runtime.
String	anklang_home_dir (const String & subdir) Get Anklang home dir, possibly adding subdir .
std::string	anklang_runpath (RPath rpath, const String & segment) Retrieve various resource paths at runtime.
String	application_name () Retrieve the localized program name intended for user display.
void	application_name_init (String desktopname) Set the application_name to a name other than program_alias if desired.
const char *	ase_build_id () Provide a string containing the ASE library build id.
const char *	ase_error_blurb (Error error) Describe Error condition.
Error	ase_error_from_errno (int sys_errno, Error fallback=Error::IO)
const char *	ase_gettext (const String & untranslated)
const char *	ase_gettext (const char * format, const A0 & a0, const Ar &... restargs) Translate a string, using the ASE locale.
const char *	ase_version () Provide a string containing the package version.
void	assertion_failed (const char * msg, const char * file, int line, const char * func) noexcept Print instructive message, handle "breakpoint", "backtrace" and "fatal-warnings" in $ASE_DEBUG.
void	assertion_fatal (const char * msg, const char * file, int line, const char * func) noexcept Print a debug message via assertion_failed() and abort the program.
void	atquit_add (std::function< void()> * func)
void	atquit_del (std::function< void()> * func)
void	atquit_run (int exitcode)
bool	atquit_triggered ()
std::string	backtrace_command () Find GDB and construct command line.
String	blake3_hash_file (const String & filename)
String	blake3_hash_string (const String & input)
void	breakpoint () Cause a debugging breakpoint, for development only.
void	call_delete (T * o) Simple way to create a standalone callback to delete an object of type T .
DeviceInfo	clap_device_info (const ClapPluginDescriptor & descriptor)
String	clap_event_to_string (const clap_event_note_t * enote)
const char *	clap_event_type_string (int etype)
void	collect_runtime_entropy (uint64 * data, size_t n) Collect entropy from the current process, usually quicker than collect_system_entropy() .
void	collect_system_entropy (uint64 * data, size_t n) Collect entropy from system devices, like interrupt counters, clocks and random devices.
constexpr bool	constexpr_equals (const char * a, const char * b, size_t n) Test string equality at compile time.
void	convert_clip_samples (size_t n, S * src, D * dst, uint16 byte_order)
void	convert_clip_samples (size_t n, const float * src, int16_t * dst, uint16 byte_order)
void	convert_samples (size_t n, S * src, D * dst, uint16 byte_order)
void	convert_samples (size_t n, const int16_t * src, float * dst, uint16 byte_order)
std::string	cpu_arch () Retrieve string identifying the CPU architecture.
String	cpu_info () Retrieve string identifying the runtime CPU type.
DeviceP	create_processor_device (AudioEngine & engine, const String & uri, bool engineproducer)
bool	cstring_to_bool (const char * string, bool fallback)
StringS	cstrings_to_vector (const char * s, ...) Construct a StringS from a NULL terminated list of string arguments.
long double	current_locale_strtold (const char * nptr, char ** endptr) Parse a double from a string ala strtod(), trying locale specific characters and POSIX/C formatting.
float	damerau_levenshtein_distance (const std::string & source, const std::string & target, const float ci, const float cd, const float cs, const float ct)
float	damerau_levenshtein_restricted (const std::string & source, const std::string & target, const float ci, const float cd, const float cs, const float ct)
Float	db2voltage (Float x) Convert Decibel to synthesizer value (Voltage).
ASE_CONST Float	db2voltage (Float x) Convert Decibel to synthesizer value (Voltage).
Float	db_changed (Float a, Float b) Determine a significant Decibel change.
ASE_CONST Float	db_changed (Float a, Float b) Determine a significant Decibel change.
void	debug (const char * cond, const char * format, const A &... args)
void ASE_ALWAYS_INLINE	debug (const char * cond, const char * format, const Args &... args) Issue a printf-like debugging message if cond is enabled by $ASE_DEBUG.
bool	debug_enabled () Check if any kind of debugging is enabled by $ASE_DEBUG.
bool	debug_key_enabled (const char * conditional) Check if conditional is enabled by $ASE_DEBUG.
bool	debug_key_enabled (const ::std::string & conditional) Check if conditional is enabled by $ASE_DEBUG.
bool	debug_key_enabled (const std::string & conditional)
::std::string	debug_key_value (const char * conditional) Retrieve the value assigned to debug key conditional in $ASE_DEBUG.
void	debug_message (const char * cond, const std::string & message) Print a debug message, called from Ase::debug().
std::string	decodefs (const std::string & utf8str) Decode UTF-8 string back into file system path representation, extracting surrogate code points as bytes.
void	diag_flush (uint8 code, const String & txt) Handle stdout and stderr printing with flushing.
String	diag_prefix (uint8 code) Create prefix for warnings and errors.
std::string	displayfs (const std::string & utf8str) Convert UTF-8 encoded file system path into human readable display format, the conversion is lossy but readable.
std::string	encodefs (const std::string & fschars) Encode a file system path consisting of bytes into UTF-8, using surrogate code points to store non UTF-8 bytes.
ChoiceS	enum_lister (const ParameterProperty &) Helper to list Jsonipc::Enum<> type values as Choice .
std::string	executable_name () Retrieve the name part of executable_path() .
std::string	executable_path () Retrieve the path to the currently running executable.
void	fast_copy (size_t n, float * d, const float * s) Copy a block of floats.
void	fast_copy (size_t n, uint32_t * d, const uint32_t * s) Copy a block of integers.
float	fast_db2voltage (float x) Float precision variant of db2voltage using fast_exp2() .
float	fast_exp2 (float x)
float	fast_hz2voltage (float x) Float precision variant of hz2voltage using fast_log2() .
float	fast_log2 (float x)
void *	fast_mem_alloc (size_t size)
void	fast_mem_free (void * mem)
float	fast_voltage2db (float x) Float precision variant of voltage2db using fast_log2() .
float	fast_voltage2hz (float x) Float precision variant of voltage2hz using fast_exp2() .
void	fatal_error (const char * format, const A &... args)
void ASE_NORETURN	fatal_error (const char * format, const Args &... args)
void	fatal_system_error (const char * file, uint line, const char * format, ...)
std::pair< std::shared_ptr< E >, ssize_t >	find_shared_by_ref (const std::vector< std::shared_ptr< E > > & v, const E & e)
void	fixed_sort (RandomIt first, RandomIt last, Compare comp=std::less< typename std::iterator_traits< RandomIt >::value_type >()) Use sorting networks to sort containers <= 16 elements without allocations.
void	floatfill (float * dst, float f, size_t n) Fill n values ofdst withf .
double	force_double (double d) Force number into double precision floating point format, even with -ffast-math .
float	force_float (float f) Force number into single precision floating point format, even with -ffast-math .
float	hz2value (float x) Convert Hertz to synthesizer value (Voltage).
Float	hz2voltage (Float x) Convert Hertz to synthesizer value (Voltage).
ASE_CONST Float	hz2voltage (Float x) Convert Hertz to synthesizer value (Voltage).
Float	hz_changed (Float a, Float b) Determine a significant frequency change (audible Hertz).
ASE_CONST Float	hz_changed (Float a, Float b) Determine a significant frequency change (audible Hertz).
ASE_CONST int	irintf (float f)
bool	is_aiff (const String & input)
bool	is_arj (const String & input)
bool	is_avi (const String & input)
bool	is_compressed (const String & input)
bool	is_gz (const String & input)
bool	is_isz (const String & input)
bool	is_jpg (const String & input)
bool	is_lz4 (const String & input)
bool	is_midi (const String & input)
bool	is_ogg (const String & input)
bool	is_pdf (const String & input)
bool	is_png (const String & input)
bool	is_wav (const String & input)
bool	is_xz (const String & input)
bool	is_zip (const String & input)
bool	is_zstd (const String & input)
bool	json_parse (const String & jsonstring, T & target) Parse a well formed JSON string and assign contents to target .
T	json_parse (const String & jsonstring) Parse a well formed JSON string and return the resulting value.
String	json_stringify (const T & source, Writ::Flags flags=Writ::Flags(0)) Create JSON string from source .
CustomDataContainer *	jsonapi_connection_data ()
JsonapiBinarySender	jsonapi_connection_sender ()
WebSocketConnectionP	jsonapi_make_connection (WebSocketConnection::Internals & internals, int logflags)
void	jsonapi_require_auth (const String & subprotocol)
String	kvpair_key (const String & key_value_pair)
String	kvpair_value (const String & key_value_pair)
bool	kvpairs_assign (StringS & kvs, const String & key_value_pair, bool casesensitive)
String	kvpairs_fetch (const StringS & kvs, const String & key, bool casesensitive)
ssize_t	kvpairs_search (const StringS & kvs, const String & k, const bool casesensitive)
StringS	list_clap_files ()
void	load_registered_drivers () Load all registered drivers.
LoftPtr< T >	loft_make_unique (Args &&... args) Construct an object T fromLoft memory, wrapped in a unique_ptr.
void	log (const LogFormat & format, const A &... args) Write a log message to the log file (or possibly stderr), using the POSIX/C locale.
LogFlags	log_setup (int * logfd) Configurable handler to open log files.
void	logmsg (const std::string & msg, const char *const filename, const uint64_t columnline, const char *const function_name)
JobQueue	main_jobs (call_main_loop)
void	main_loop_autostop_mt ()
void	main_loop_wakeup ()
MidiEvent	make_aftertouch (uint16 chnl, uint8 mkey, float velo, float tune, uint nid)
AudioEngine &	make_audio_engine (const VoidF & owner_wakeup, uint sample_rate, SpeakerArrangement speakerarrangement)
MidiEvent	make_control (uint16 chnl, uint prm, float val)
MidiEvent	make_control8 (uint16 chnl, uint prm, uint8 cval)
std::function< void(Value &)>	make_enum_getter (Enum * v) Value getter for enumeration types.
std::function< bool(const Value &)>	make_enum_setter (Enum * v) Value setter for enumeration types.
MidiEvent	make_note_off (uint16 chnl, uint8 mkey, float velo, float tune, uint nid)
MidiEvent	make_note_on (uint16 chnl, uint8 mkey, float velo, float tune, uint nid)
MidiEvent	make_param_value (uint param, double pvalue)
MidiEvent	make_pitch_bend (uint16 chnl, float val)
MidiEvent	make_pressure (uint16 chnl, float velo)
MidiEvent	make_program (uint16 chnl, uint prgrm)
void	memset4 (uint32 * mem, uint32 filler, uint length) Fill a memory area with a 32-bit quantitiy.
uint64	monotonic_counter () A monotonically increasing counter, increments are atomic and visible in all threads.
String	now_strftime (const String & format)
constexpr bool	operator! (Error error)
ChoiceS &	operator+= (ChoiceS & choices, Choice && newchoice) Convenience ChoiceS construciton helper.
bool	operator== (const std::vector< ValueP > & v1, const std::vector< ValueP > & v2)
constexpr Re::Flags	operator| (Re::Flags a, Re::Flags b)
String	parameter_guess_nick (const String & parameter_label) Create a few letter nick name from a multi word parameter label.
long double	posix_locale_strtold (const char * nptr, char ** endptr) Parse a double from a string ala strtod(), trying locale specific characters and POSIX/C formatting.
void void	printerr (const char * format, const A &... args)
void	printerr (const char * format, const Args &... args) Print a message on stderr (and flush stderr) ala printf(), using the POSIX/C locale.
void	printout (const char * format, const A &... args)
void	printout (const char * format, const Args &... args) Print a message on stdout (and flush stdout) ala printf(), using the POSIX/C locale.
String	program_alias () Retrieve the program name as used for logging or debug messages.
void	program_alias_init (String customname) Set program_alias to a non-localized alias other than program_argv0 if desired.
String	program_cwd () The current working directory during startup.
double	random_float ()
double	random_frange (double begin, double end)
uint64_t	random_int64 ()
int64_t	random_irange (int64_t begin, int64_t end)
uint64_t	random_nonce () Provide a unique 64 bit identifier that is not 0, see also random_int64() .
void	random_secret (uint64_t * secret_var) Generate a secret non-zero nonce in secret_var, unless it has already been assigned.
CString	register_audio_processor (const char * aseid=nullptr) Add an AudioProcessor derived type to the audio processor registry.
bool *	register_driver_loader (const char * staticwhat, Error(*)() loader) Register loader callbacks at static constructor time.
bool	sched_fast_priority (int tid) Try to acquire low latency scheduling priority, returns true if nice level is < 0.
int	sched_get_priority (int tid) Retrieve the nice level of process or thread tid .
bool	sched_set_priority (int tid, int nicelevel) Try to set the nice level of process or thread tid tonicelevel .
void	sha3_224_hash (const void * data, size_t data_length, uint8_t hashvalue) Calculate 224 bit SHA3 digest from data , see also classSHA3_224 .
void	sha3_256_hash (const void * data, size_t data_length, uint8_t hashvalue) Calculate 256 bit SHA3 digest from data , see also classSHA3_256 .
void	sha3_384_hash (const void * data, size_t data_length, uint8_t hashvalue) Calculate 384 bit SHA3 digest from data , see also classSHA3_384 .
void	sha3_512_hash (const void * data, size_t data_length, uint8_t hashvalue) Calculate 512 bit SHA3 digest from data , see also classSHA3_512 .
void	shake128_hash (const void * data, size_t data_length, uint8_t * hashvalues, size_t n) Calculate SHA3 extendable output digest for 128 bit security strength, see also class SHAKE128 .
void	shake256_hash (const void * data, size_t data_length, uint8_t * hashvalues, size_t n) Calculate SHA3 extendable output digest for 256 bit security strength, see also class SHAKE256 .
std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (Source * object)
const std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (const Source * object) See shared_ptr_cast(Source*) .
std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (std::shared_ptr< Source > & sptr) See shared_ptr_cast(Source*) .
const std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (const std::shared_ptr< Source > & sptr) See shared_ptr_cast(Source*) .
std::shared_ptr< typename std::remove_pointer< Source >::type >	shared_ptr_from (Source * object) Use shared_ptr_cast<>() to convert an object pointer into ashared_ptr<> .
const char *	speaker_arrangement_bit_name (SpeakerArrangement spa)
SpeakerArrangement	speaker_arrangement_channels (SpeakerArrangement spa)
uint8	speaker_arrangement_count_channels (SpeakerArrangement spa)
std::string	speaker_arrangement_desc (SpeakerArrangement spa)
bool	speaker_arrangement_is_aux (SpeakerArrangement spa)
float	square_max (uint n_values, const float * ivalues) Find the maximum suqared value in a block of floats.
float	square_sum (uint n_values, const float * ivalues) Calculate suqare sum of a block of floats.
StreamReaderP	stream_reader_from_file (const String & file)
StreamReaderP	stream_reader_zip_member (const String & archive, const String & member, Storage::StorageFlags f)
StreamReaderP	stream_reader_zstd (StreamReaderP & istream)
StreamWriterP	stream_writer_create_file (const String & filename, int mode)
StreamWriterP	stream_writer_zstd (const StreamWriterP & ostream, int level)
const char *	strerror (int errno_num) Get POSIX locale strerror.
const char *	strerror ()
String	string_canonify (const String & string, const String & valid_chars, const String & substitute)
String	string_capitalize (const String & str, size_t maxn, bool rest_tolower) Capitalize words, so the first letter is upper case, the rest lower case.
int	string_casecmp (const String & s1, const String & s2) Like strcasecmp(3) for UTF-8 strings.
String	string_casefold (const String & src) Yield UTF-8 string useful for case insensitive comparisons.
int	string_cmp (const String & s1, const String & s2) Like strcmp(3) for UTF-8 strings.
int	string_cmp_uuid (const String & uuid_string1, const String & uuid_string2) Returns whether uuid_string1 compares smaller (-1), equal (0) or greater (+1) to__uuid_string2 .
const char *	string_demangle_cxx (const char * mangled_identifier) noexcept Demangle identifier via libcc.
bool	string_endswith (const String & string, const String & fragment) Returns whether string ends withfragment .
bool	string_endswith (const String & string, const StringS & fragments) Returns whether string ends with any element offragments .
const char *	string_find_word (const char * haystack, const char * word) Find occurance of word inhaystack .
std::string	string_format (const char * format, const Args &... args) Format a string similar to sprintf(3) with support for std::string and std::ostringstream convertible objects.
String	string_from_bool (bool value) Convert a boolean value into a string.
String	string_from_cquote (const String & input) Parse a possibly quoted C string into regular string.
String	string_from_double (double value) Convert a double into a string, using the POSIX/C locale.
String	string_from_double_vector (const std::vector< double > & dvec, const String & delim) Construct a string out of all double values passed in dvec , separated by__delim .
String	string_from_errno (int errno_val) Returns a String describing the passed in errno value, similar to strerror().
String	string_from_float (float value) Convert a float into a string, using the POSIX/C locale.
String	string_from_float (double value)
String	string_from_int (int64 value) Convert a 64bit signed integer into a string.
String	string_from_long_double (long double value) Convert a long double into a string, using the POSIX/C locale.
String	string_from_pretty_function_name (const char * cxx_pretty_function)
String	string_from_type (Type value) Create a string from a templated argument value, such as bool, int, double.
String	string_from_type< String > (String value)
String	string_from_type< bool > (bool value)
String	string_from_type< double > (double value)
String	string_from_type< float > (float value)
String	string_from_type< int > (int value)
String	string_from_type< int16 > (int16 value)
String	string_from_type< int64 > (int64 value)
String	string_from_type< long double > (long double value)
String	string_from_type< uint > (uint value)
String	string_from_type< uint16 > (uint16 value)
String	string_from_type< uint64 > (uint64 value)
String	string_from_uint (uint64 value) Convert a 64bit unsigned integer into a string.
bool	string_has_int (const String & string) Checks if a string contains a digit, optionally preceeded by whitespaces.
String	string_hexdump (const void * addr, size_t length, size_t initial_offset)
bool	string_is_ascii_alnum (const String & str)
bool	string_is_canonified (const String & string, const String & valid_chars) Check if string_canonify() would modify__string .
bool	string_is_ncname (const String & input)
bool	string_is_uuid (const String & uuid_string) Returns whether uuid_string contains a properly formatted UUID string.
bool	string_islower (const String & str) Check if all string characters are Unicode lower case characters.
bool	string_isupper (const String & str) Check if all string characters are Unicode upper case characters.
String	string_join (const String & junctor, const StringS & strvec)
String	string_locale_vprintf (const char * format, va_list vargs) Formatted printing like string_vprintf using the current locale.
String	string_lstrip (const String & input) Strip whitespaces from the left of a string.
bool	string_match_identifier (const String & ident1, const String & ident2) Check equality of strings canonicalized to "[0-9a-z_]+".
bool	string_match_identifier_tail (const String & ident, const String & tail) Variant of string_match_identifier() that matches__tail against__ident at word boundary.
String	string_multiply (const String & s, uint64 count) Reproduce a string s for__count times.
String	string_normalize_nfc (const String & src) Yield normalized composed UTF-8 string.
String	string_normalize_nfd (const String & src) Yield normalized decomposed UTF-8 string.
String	string_normalize_nfkc (const String & src) Formatting stripped normalized composed UTF-8 string.
String	string_normalize_nfkd (const String & src) Formatting stripped normalized decomposed UTF-8 string.
bool	string_option_check (const String & optionlist, const String & feature) Check if an option is set/unset in an options list string.
String	string_option_find (const String & optionlist, const String & feature, const String & fallback) Retrieve the option value from an options list separated by ':' or ';' or fallback .
std::string_view	string_option_find_value (const char * string, const char * feature, const String & fallback, const String & denied, bool matchallnone) Low level option search, avoids dynamic allocations.
String	string_replace (const String & input, const String & marker, const String & replacement, size_t maxn) Replace substring marker in__input with__replacement , at most__maxn times.
String	string_rstrip (const String & input) Strip whitespaces from the right of a string.
const String &	string_set_A2Z () Returns a string containing all of A-Z.
const String &	string_set_a2z () Returns a string containing all of a-z.
const String &	string_set_ascii_alnum () Returns a string containing all of 0-9, A-Z and a-z.
StringS	string_split (const String & string, const String & splitter, size_t maxn)
StringS	string_split_any (const String & string, const String & splitchars, size_t maxn)
bool	string_startswith (const String & string, const String & fragment) Returns whether string starts withfragment .
bool	string_startswith (const String & string, const StringS & fragments) Returns whether string starts with any element offragments .
String	string_strip (const String & input) Strip whitespaces from the left and right of a string.
String	string_substitute_char (const String & input, const char match, const char subst) Replace all occouranes of match in__input with__subst .
bool	string_to_bool (const String & string, bool fallback)
String	string_to_cescape (const String & str)
String	string_to_cquote (const String & str) Returns a string as C string including double quotes.
double	string_to_double (const String & string) Parse a double from a string, trying locale specific characters and POSIX/C formatting.
double	string_to_double (const char * dblstring, const char ** endptr) Similar to string_to_double(const String&) , but returns the first failing character position in__endptr .
std::vector< double >	string_to_double_vector (const String & string) Parse a string into a list of doubles, expects ';' as delimiter.
double	string_to_float (const String & string)
String	string_to_hex (const String & input) Convert bytes in string input to hexadecimal numbers.
String	string_to_identifier (const String & input) Force lower case, alphanumerics + underscore and non-digit start.
int64	string_to_int (const String & string, size_t * consumed, uint base) Parse a string into a 64bit integer, optionally specifying the expected number base.
long double	string_to_long_double (const String & string) Parse a long double from a string, trying locale specific characters and POSIX/C formatting.
long double	string_to_long_double (const char * dblstring, const char ** endptr) Similar to string_to_long_double(const String&) , but returns the first failing character position in__endptr .
String	string_to_ncname (const String & input, uint32_t substitute)
double	string_to_seconds (const String & string, double fallback) Parse string into seconds.
Type	string_to_type (const String & string) Convert a string to template argument type, such as bool, int, double.
String	string_to_type< String > (const String & string)
bool	string_to_type< bool > (const String & string)
double	string_to_type< double > (const String & string)
float	string_to_type< float > (const String & string)
int	string_to_type< int > (const String & string)
int16	string_to_type< int16 > (const String & string)
int64	string_to_type< int64 > (const String & string)
long double	string_to_type< long double > (const String & string)
uint	string_to_type< uint > (const String & string)
uint16	string_to_type< uint16 > (const String & string)
uint64	string_to_type< uint64 > (const String & string)
uint64	string_to_uint (const String & string, size_t * consumed, uint base) Parse a string into a 64bit unsigned integer, optionally specifying the expected number base.
String	string_tolower (const String & str) Convert all string characters into Unicode lower case characters.
String	string_totitle (const String & str) Convert all string characters into Unicode title characters.
String	string_toupper (const String & str) Convert all string characters into Unicode upper case characters.
String	string_url_decode (const String & urlstr, const bool form_url_encoded) Decode URL %-sequences in a string, decode '+' if form_url_encoded .
String	string_url_encode (const String & rawstr, const bool form_url_encoded) Encode special characters to URL %-sequences, encode space as '+' if form_url_encoded .
void	string_vector_erase_empty (StringS & svector) Remove empty elements from a string vector.
String	string_vector_find (const StringS & svector, const String & prefix, const String & fallback)
String	string_vector_find_value (const StringS & svector, const String & prefix, const String & fallback)
void	string_vector_lstrip (StringS & svector) Left-strip all elements of a string vector, see string_lstrip() .
void	string_vector_rstrip (StringS & svector) Right-strip all elements of a string vector, see string_rstrip() .
void	string_vector_strip (StringS & svector) Strip all elements of a string vector, see string_strip() .
String	string_vprintf (const char * format, va_list vargs) Formatted printing ala vprintf() into a String, using the POSIX/C locale.
String	stringify_clip_note (const ClipNote & n)
StringS	strings_version_sort (const StringS & strings, bool reverse)
void	strings_version_sort (StringS * strings, bool reverse)
const char *	strrstr (const char * haystack, const char * needle)
TelemetryField	telemetry_field (const String & name, const T * field)
bool	text_convert (const String & to_charset, String & output_string, const String & from_charset, const String & input_string, const String & fallback_charset, const String & output_mark)
String	this_thread_get_name ()
int	this_thread_getpid ()
int	this_thread_gettid ()
bool	this_thread_is_ase ()
int	this_thread_online_cpus ()
ThreadId	this_thread_self ()
void	this_thread_set_name (const String & name16chars)
uint64	timestamp_benchmark () Returns benchmark timestamp in nano-seconds, clock starts around program startup.
String	timestamp_format (uint64 stamp, uint maxlength) Convert stamp into a string, adding µsecond fractions if space permits.
uint64_t	timestamp_now () Current time in µseconds.
uint64	timestamp_realtime () Return the current time as uint64 in µseconds.
uint64	timestamp_resolution () Provide resolution of timestamp_benchmark() in nano-seconds.
uint64	timestamp_startup () Provides the timestamp_realtime() value from program startup.
constexpr uint16_t	uint16_swap_le_be (uint16_t v) Swap 16-Bit integers between __BIG_ENDIAN and __LITTLE_ENDIAN systems.
constexpr uint32_t	uint32_swap_le_be (uint32_t v) Swap 32-Bit integers between __BIG_ENDIAN and __LITTLE_ENDIAN systems.
constexpr uint64_t	uint64_swap_le_be (uint64_t v) Swap 64-Bit integers between __BIG_ENDIAN and __LITTLE_ENDIAN systems.
constexpr bool	unicode_is_assigned (uint32_t u) Return whether u matches any of the assigned Unicode planes.
constexpr bool	unicode_is_character (uint32_t u) Return whether u is not one of the 66 Unicode noncharacters.
constexpr bool	unicode_is_control_code (uint32_t u) Return whether u is one of the 65 Unicode control codes.
constexpr bool	unicode_is_noncharacter (uint32_t u) Return whether u is one of the 66 Unicode noncharacters.
constexpr bool	unicode_is_private (uint32_t u) Return whether u is in one of the 3 private use areas of Unicode.
constexpr bool	unicode_is_valid (uint32_t u) Return whether u is an allowed Unicode codepoint within 0x10FFFF and not part of a UTF-16 surrogate pair.
int	user_id ()
String	user_name ()
String	user_real_name ()
size_t	utf8_to_unicode (const char * str, uint32_t * codepoints)
size_t	utf8_to_unicode (const std::string & str, std::vector< uint32_t > & codepoints)
std::vector< uint32_t >	utf8decode (const std::string & utf8str) Convert valid UTF-8 sequences to Unicode codepoints, invalid sequences are treated as Latin-1 characters.
std::string	utf8encode (const uint32_t * codepoints, size_t n_codepoints) Convert codepoints into an UTF-8 string, using the shortest possible encoding.
std::string	utf8encode (const std::vector< uint32_t > & codepoints) Convert codepoints into an UTF-8 string, using the shortest possible encoding.
size_t	utf8len (const char * str) Count valid UTF-8 sequences, invalid sequences are counted as Latin-1 characters.
size_t	utf8len (const std::string & str) Count valid UTF-8 sequences, invalid sequences are counted as Latin-1 characters.
float	value2hz (float x) Convert synthesizer value (Voltage) to Hertz.
Float	voltage2db (Float x) Convert synthesizer value (Voltage) to Decibel.
ASE_CONST Float	voltage2db (Float x) Convert synthesizer value (Voltage) to Decibel.
Float	voltage2hz (Float x) Convert synthesizer value (Voltage) to Hertz.
ASE_CONST Float	voltage2hz (Float x) Convert synthesizer value (Voltage) to Hertz.
Float	voltage_changed (Float a, Float b) Determine a significant synthesizer value (Voltage) change.
ASE_CONST Float	voltage_changed (Float a, Float b) Determine a significant synthesizer value (Voltage) change.
void	warning (const char * format, const A &... args)
void	warning (const char * format, const Args &... args) Issue a printf-like warning message.
WaveWriterP	wave_writer_create_flac (int rate, int channels, const String & filename, int mode, int compresion)
WaveWriterP	wave_writer_create_opus (int rate, int channels, const String & filename, int mode, int complexity, float bitrate)
WaveWriterP	wave_writer_create_wav (int rate, int channels, const String & filename, int mode, uint8_t n_bits)
String	wave_writer_flac_version ()
String	wave_writer_opus_version ()
std::shared_ptr< C >	weak_ptr_fetch_or_create (std::weak_ptr< C > & wptr, const std::function< std::shared_ptr< C >()> & ctor) Fetch shared_ptr fromwptr and createC withctor if needed.
uint8 *	zintern_decompress (unsigned int decompressed_size, const unsigned char * cdata, unsigned int cdata_size)
void	zintern_free (uint8 * dc_data) Free data returned from zintern_decompress() .
String	zstd_compress (const String & input, int level)
String	zstd_compress (const void * src, size_t src_size, int level)
ssize_t	zstd_target_size (const String & input)
ssize_t	zstd_uncompress (const String & input, void * dst, size_t dst_size)
String	zstd_uncompress (const String & input)

Public Static Functions

Type	Name
bool	__attribute__ ((__unused__))
void	__attribute__ ((__noinline__))
const clap_plugin *	access_clap_plugin (ClapPluginHandle * handle)
iconv_t	aliased_iconv_open (const String & tocode, const String & fromcode)
uint	alloc_id ()
String	anklang_cachedir_base (bool createbase=false) Find base directory for the creation of temporary caches.
const char *	anklang_host_name ()
void	apply_driver_preferences ()
void	assertion_abort (const char * msg, const char * file, int line, const char * func) noexcept
void	atexit_clean_cachedirs () Clean temporary caches of this process.
std::atomic< EngineJobImpl * > &	atomic_next_ptrref (EngineJobImpl * j)
std::atomic< AudioEngineThread::UserNoteJob * > &	atomic_next_ptrref (AudioEngineThread::UserNoteJob * j)
std::atomic< RtCallJob * > &	atomic_next_ptrref (RtCallJob * j)
uint64_t	bit_rotate64 (uint64_t bits, unsigned int offset) Rotate left for uint64_t.
ASE_CONST uint64_t	byte_hash64 (const Num * data, size_t length) Fast byte hashing with good dispersion and runtime randomization.
bool	c_isalnum (uint8 c)
void	call_main_loop (const std::function< void()> & fun)
Choice	choice_from_driver_entry (const DriverEntry & e, const String & icon_keywords)
String	clapid (const clap_host * host)
auto &	cml_set ()
bool	codepoint_is_namestartchar (uint32_t c)
bool	codepoint_is_ncname (uint32_t c)
std::string	construct_ladspa_path ()
void ASE_NORETURN	cpu_info_sigill_handler (int dummy)
String	current_locale_vprintf (const char * format, va_list vargs)
const PwdUser &	current_user ()
float	damerau_levenshtein_unrestricted (const std::string_view & source, const std::string_view & target, const float ci, const float cd, const float cs, const float ct)
std::string	determine_anklangsynthengine_installdir (bool * using_objdir)
bool	dispatch_loft_lowmem (const Ase::LoopState & lstate)
constexpr T	divmod (T dividend, T divisor, T * reminderp) Compute integers division and modulo with one X86 asm instruction.
Blob	error_result (String url, int fallback_errno=EINVAL, String msg="failed to load")
bool	event_unions_try_push (ClapEventUnionS & events, const clap_event_header_t * event)
String	feature_canonify (const String & str)
String	find_anklang_parent_dir (const String & path)
const char *	find_option (const char * haystack, const char *const needle, const size_t l, const int allowoption)
std::string	find_text_file (ptrdiff_t symbol_address) Find the binary file containing the runtime symbol at symbol_address .
uint32_t	flags_to_pcre2_compile_options (Re::Flags flags)
constexpr uint64_t	fnv1a_consthash64 (const Num * ztdata)
constexpr uint64_t	fnv1a_consthash64 (const Num *const data, size_t length) Variant of fnv1a_consthash64() for memory blocks of arbitrary size.
void	get_arc4random (uint64 * u, uint count)
const char *	get_arch_name (void)
std::string	get_executable_path ()
PwdUser	get_pwd_user (int uid)
bool	get_rdrand (uint64 * u, uint count)
bool	get_x86_cpu_features (CPUInfo * ci)
const char *	getenv_ase_debug ()
int	getrandom (void * buffer, size_t count, unsigned flags)
uint64_t	global_random64 ()
int	guess_zstd_level (size_t input_size)
bool	handle_autostop (const LoopState & state)
ClapPluginHandleImpl *	handle_ptr (const clap_host * host)
ClapPluginHandleImplP	handle_sptr (const clap_host * host)
bool	has_debug_key (const char *const debugkeys, const char *const key) Quick boolean check for a colon separated key in a haystack.
void	hash_anything (KeccakRng & pool, const Data & data)
void	hash_cpu_usage (KeccakRng & pool)
bool	hash_file (KeccakRng & pool, const char * filename, const size_t maxbytes=16384)
bool	hash_getrandom (KeccakRng & pool)
bool	hash_macs (KeccakRng & pool)
ASE_PURE uint64_t	hash_secret () Provide hashing nonce for reseeding hashes at program start to avoid collision attacks.
bool	hash_stat (KeccakRng & pool, const char * filename)
void	hash_sys_structs (KeccakRng & pool)
bool	host_call_on_timer (ClapPluginHandleImplP handlep, clap_id timer_id)
void	host_file_reference_changed (const clap_host_t * host)
void	host_file_reference_set_dirty (const clap_host_t * host, clap_id resource_id)
const void *	host_get_extension_mt (const clap_host * host, const char * extension_id)
void	host_gui_closed (const clap_host_t * host, bool was_destroyed)
ulong	host_gui_create_x11_window (ClapPluginHandleImplP handlep, int width, int height)
void	host_gui_delete_request (ClapPluginHandleImplP handlep)
bool	host_is_audio_thread (const clap_host_t * host)
bool	host_is_main_thread (const clap_host_t * host)
bool	host_is_rescan_flag_supported (const clap_host_t * host, uint32_t flag)
void	host_log (const clap_host_t * host, clap_log_severity severity, const char * msg)
bool	host_modify_fd (const clap_host_t * host, int fd, clap_posix_fd_flags_t flags)
void	host_params_clear (const clap_host_t * host, clap_id param_id, clap_param_clear_flags flags)
void	host_params_rescan (const clap_host_t * host, clap_param_rescan_flags flags)
bool	host_register_fd (const clap_host_t * host, int fd, clap_posix_fd_flags_t flags)
bool	host_register_timer (const clap_host * host, uint32_t period_ms, clap_id * timer_id)
void	host_request_callback_mt (const clap_host * host)
void	host_request_flush (const clap_host_t * host)
bool	host_request_hide (const clap_host_t * host)
void	host_request_process_mt (const clap_host * host)
bool	host_request_resize (const clap_host_t * host, uint32_t width, uint32_t height)
void	host_request_restart_mt (const clap_host * host)
bool	host_request_show (const clap_host_t * host)
void	host_rescan (const clap_host_t * host, uint32_t flag)
void	host_resize_hints_changed (const clap_host_t * host)
bool	host_unregister_fd (const clap_host_t * host, int fd)
bool	host_unregister_timer (const clap_host * host, clap_id timer_id)
char	identifier_char_canon (char c)
bool	identifier_match (const char * str1, const char * str2)
void	init_sigpipe ()
const char *	initialized_ase_gettext_domain () Initialize gettext domain for ASE.
void	interleaved_stereo (const size_t n_frames, float * buffer, AudioProcessor & proc, OBusId obus)
bool	is_anklang_dir (const String & path)
bool	is_localhost (const String & url, int port)
bool	is_separator (char c)
long double	libc_strtold (const char * nptr, char ** endptr)
void	logstart ()
bool	main_rt_jobs_pending ()
void	main_rt_jobs_process ()
bool	make_anklang_dir (const String & path)
String	make_auth_string ()
auto	make_case_table (const MkFun & mkjump)
Jsonipc::IpcDispatcher *	make_dispatcher ()
auto	make_indexed_table (const MkFun & mkjump, std::index_sequence< INDICES... >) Create a std::array<Fun,N> , whereFun is returned frommkjump (INDICES…) .
String3	make_nick3 (const String & label)
bool	match_identifier_detailed (const String & ident, const String & tail)
void	maybe_save_preferences ()
ChoiceS	midi_driver_pref_list_choices (const CString & ident)
MinMaxStep	minmaxstep_from_initialval (const Param::InitialVal & iv, bool * isbool)
void	mpc_add (uint64_t *const a, const uint64_t *const b, const uint64_t *const m)
void	mpc_bsub (uint64_t *const a, const uint64_t *const b)
int	mpc_cmp (const uint64_t *const a, const uint64_t *const b)
void	mpc_mul (uint64_t *const a, const uint64_t *const b, const uint64_t *const m)
void	mpc_rem (uint64_t *const a, const uint64_t *const m)
EnumInfo	musical_tuning_info (MusicalTuning musicaltuning)
void	notify_loft_lowmem ()
void	notify_preference_listeners ()
bool	operator!= (const WppHdl & a, const WppHdl & b)
bool	operator== (const WppHdl & a, const WppHdl & b)
void	parse_args (int * argcp, char ** argv, MainAppImpl & config)
bool	parse_assignment (const char ** stringp, size_t * linenop, String * keyp, String * localep, String * valuep)
bool	parse_section (const char ** stringp, size_t * linenop, String * sectionp)
bool	parse_whitespaces (const char ** stringp, int min_spaces)
String	pathname_anklangrc ()
ASE_CONST uint32_t	pcg_hash32 (const Num * data, size_t length, uint64_t seed)
ASE_CONST uint64_t	pcg_hash64 (const Num * data, size_t length, uint64_t seed)
ASE_CONST uint64_t	pcg_hash64 (const char * ztdata, uint64_t seed) pcg_hash64() variant for zero-terminated strings.
ChoiceS	pcm_driver_pref_list_choices (const CString & ident)
pcre2_compile_context *	pcre2compilecontext ()
String	pid_string (int pid) Create process specific string for a .pid guard file.
String	posix_locale_vprintf (const char * format, va_list vargs)
void	preallocate_loft (size_t preallocation)
void	prefault_pages (size_t stacksize, size_t heapsize)
PrefsMap &	prefs_map ()
void	print_usage (bool help)
void	queue_notify_preference_listeners (const CString & cident)
RegisteredLoaderVector &	registered_loaders ()
void	release_id (uint id)
constexpr UInt	rotl (UInt bits, uint32_t offset) Bitwise rotate-left pattern recognized by gcc & clang at -O1 iff sizeof (bits) == {8,16,32,64}.
constexpr UInt	rotr (UInt bits, uint32_t offset) Bitwise rotate-right pattern recognized by gcc & clang at -O1 iff sizeof (bits) == {8,16,32,64}.
void	run_tests_and_quit ()
void	runtime_entropy (KeccakRng & pool)
bool	scan_escaped (const char ** stringp, size_t * linenop, const char term)
bool	scan_value (const char ** stringp, size_t * linenop, String * valuep, const char * termchars="")
ssize_t	search_first_digit (const String & s)
ssize_t	search_last_digits (const String & s)
size_t	separator_strlen (const char *const s)
clap_event_note *	setup_evnote (ClapEventUnion * evunion, uint32_t time, uint16_t port_index)
clap_event_note_expression *	setup_expression (ClapEventUnion * evunion, uint32_t time, uint16_t port_index)
clap_event_midi *	setup_midi1 (ClapEventUnion * evunion, uint32_t time, uint16_t port_index)
bool	skip_commentline (const char ** stringp, size_t * linenop, String * commentp=NULL)
bool	skip_line (const char ** stringp, size_t * linenop, String * textp)
bool	skip_to_eol (const char ** stringp, size_t * linenop)
bool	skip_whitespaces (const char ** stringp)
String	spaced_nums (String s)
ASE_CONST uint64_t	string_hash64 (const std::string & string) Fast string hashing with good dispersion for std::string and runtime randomization.
ASE_CONST uint64_t	string_hash64 (const char * ztdata) pcg_hash64() variant for zero-terminated strings.
std::string_view	string_option_find_value (const char * string, const char * feature, const char * fallback, const char * denied, const int matching)
String	string_read (const String & filename, const int fd, size_t guess)
String	string_rtrim (String & str)
StringS	string_whitesplit (const String & string, size_t maxn)
void	system_entropy (KeccakRng & pool)
constexpr const char *	telemetry_type (const int8 & field)
constexpr const char *	telemetry_type (const int32 & field)
constexpr const char *	telemetry_type (const float & field)
constexpr const char *	telemetry_type (const double & field)
void	timestamp_init_ ()
String	tmpdir_prefix () Prefix for temporary cache directories, also used for pruning of stale directories.
void	try_load_x11wrapper ()
ASE_PURE const char *	typeid_name () Provide demangled stringified name for type T .
ASE_PURE const char *	typeid_name (T & obj) Provide demangled stringified name for object obj .
bool	unalias_encoding (String & name)
T *	unalias_ptr (T * ptr) Force compiler to forget the origin of a possibly aliasing pointer.
bool	update_task_status (TaskStatus & self)
size_t	utf8character (const char * str, uint32_t * unicode)
size_t	utf8codepoint (const char * str, uint32_t * unicode) Returns length of unicode character in bytes.
size_t	utf8skip (const char * str) Returns length of unicode character in bytes.
bool	validate_telemetry_segments (const TelemetrySegmentS & segments, size_t * payloadlength)
String	value_array_to_string (const ValueS & vec)
Value	value_from_initialval (const Param::InitialVal & iv)
String	value_record_to_string (const ValueR & vec)
std::vector< unsigned char >	wav_header (const uint8_t n_bits, const uint32_t n_channels, const uint32_t sample_freq, const uint32_t n_samples)
int	wav_write (int fd, uint8_t n_bits, uint32_t n_channels, uint32_t sample_freq, const float * samples, size_t n_frames)
std::array< char, 12 >	write_uint (uint32_t i)

Detailed Description

@TODO: * StringFormatter: support directives: %n %S %ls * StringFormatter: support directive flags: I

Public Types Documentation

enum Ase

enum Ase::Ase {
    WAITING = 0,
    PREPARED,
    NEEDS_DISPATCH
};

---

union ClapEventUnion

---

union FloatIEEE754

Union to compartmentalize an IEEE-754 float. IEEE 754 single precision floating point layout:

       31 30           23 22            0
+--------+---------------+---------------+
| s 1bit | e[30:23] 8bit | f[22:0] 23bit |
+--------+---------------+---------------+
B0------------------->B1------->B2-->B3-->

---

typedef Atomic

Substitute for std::atomic<> with fixes for GCC.

using Ase::Atomic = typedef boost::atomic<T>;

---

typedef AtomicU64

using Ase::AtomicU64 = typedef std::atomic<uint64>;

---

typedef CStringS

using Ase::CStringS = typedef std::vector<CString>;

---

enum CacheType

enum Ase::CacheType {
    CACHE_NEVER,
    CACHE_AUTO,
    CACHE_BRIEFLY,
    CACHE_FOREVER
};

---

typedef CallbackS

using Ase::CallbackS = typedef std::vector<std::function<void()> >;

---

typedef ChoicesFunc

Handler to generate all possible parameter choices dynamically.

using Ase::ChoicesFunc = typedef std::function<ChoiceS(const CString&)>;

---

typedef ClapEventParamS

using Ase::ClapEventParamS = typedef std::vector<clap_event_param_value>;

---

typedef ClapEventUnionS

using Ase::ClapEventUnionS = typedef std::vector<ClapEventUnion>;

---

typedef ClapParamIdValue

using Ase::ClapParamIdValue = typedef std::tuple<clap_id,double>;

---

typedef ClapParamIdValueS

using Ase::ClapParamIdValueS = typedef std::vector<ClapParamIdValue>;

---

typedef ClapParamInfoMap

using Ase::ClapParamInfoMap = typedef std::unordered_map<clap_id,ClapParamInfoImpl*>;

---

typedef ClapParamInfoS

using Ase::ClapParamInfoS = typedef std::vector<ClapParamInfo>;

---

typedef ClapParamUpdateS

using Ase::ClapParamUpdateS = typedef std::vector<ClapParamUpdate>;

---

typedef ClapResourceHash

using Ase::ClapResourceHash = typedef std::tuple<clap_id,String>;

---

typedef ClapResourceHashS

using Ase::ClapResourceHashS = typedef std::vector<ClapResourceHash>;

---

typedef ClipImplGeneratorS

using Ase::ClipImplGeneratorS = typedef std::vector<ClipImpl::Generator>;

---

typedef DCallbackS

using Ase::DCallbackS = typedef std::vector<std::function<void(double)> >;

---

typedef DispatcherSourceP

typedef std::shared_ptr<DispatcherSource> Ase::DispatcherSourceP;

---

typedef DriverP

using Ase::DriverP = typedef Driver::DriverP;

---

enum Error

Enum representing Error states.

enum Ase::Error {
    NONE = 0,
    PERMS = EPERM,
    IO = EIO,
    NO_MEMORY = ENOMEM,
    NO_SPACE = ENOSPC,
    NO_FILES = ENFILE,
    MANY_FILES = EMFILE,
    RETRY = EINTR,
    NOT_DIRECTORY = ENOTDIR,
    FILE_NOT_FOUND = ENOENT,
    FILE_IS_DIR = EISDIR,
    FILE_EXISTS = EEXIST,
    FILE_BUSY = EBUSY,
    INTERNAL = 0x30000000,
    UNIMPLEMENTED,
    FILE_EOF = 0x30001000,
    FILE_OPEN_FAILED,
    FILE_SEEK_FAILED,
    FILE_READ_FAILED,
    FILE_WRITE_FAILED,
    PARSE_ERROR = 0x30002000,
    NO_HEADER,
    NO_SEEK_INFO,
    NO_DATA_AVAILABLE,
    DATA_CORRUPT,
    WRONG_N_CHANNELS,
    FORMAT_INVALID,
    FORMAT_UNKNOWN,
    DATA_UNMATCHED,
    CODEC_FAILURE,
    BROKEN_ARCHIVE,
    BAD_PROJECT,
    NO_PROJECT_DIR,
    DEVICE_NOT_AVAILABLE = 0x30003000,
    DEVICE_ASYNC,
    DEVICE_BUSY,
    DEVICE_FORMAT,
    DEVICE_BUFFER,
    DEVICE_LATENCY,
    DEVICE_CHANNELS,
    DEVICE_FREQUENCY,
    DEVICES_MISMATCH,
    WAVE_NOT_FOUND = 0x30004000,
    INVALID_PROPERTY,
    INVALID_MIDI_CONTROL,
    OPERATION_BUSY
};

---

typedef EventConnectionP

using Ase::EventConnectionP = typedef std::shared_ptr<EventConnection>;

---

typedef EventConnectionW

using Ase::EventConnectionW = typedef std::weak_ptr<EventConnection>;

---

typedef EventHandler

using Ase::EventHandler = typedef std::function<void (const Event&)>;

---

typedef EventLoopP

typedef std::shared_ptr<EventLoop> Ase::EventLoopP;

---

typedef EventSourceP

typedef std::shared_ptr<EventSource> Ase::EventSourceP;

---

typedef FastRng

using Ase::FastRng = typedef Mwc256;

---

enum IBusId

ID type for AudioProcessor input buses, buses are numbered with increasing index.

enum Ase::IBusId;

---

typedef IDX

using Ase::IDX = typedef typename ::std::enable_if<I == J, bool>::type;

---

typedef InstanceP

using Ase::InstanceP = typedef std::shared_ptr<SharedBase>;

---

typedef JsonapiBinarySender

using Ase::JsonapiBinarySender = typedef std::function<bool(const String&)>;

---

typedef JsonapiConnectionP

using Ase::JsonapiConnectionP = typedef std::shared_ptr<JsonapiConnection>;

---

typedef JsonapiConnectionW

using Ase::JsonapiConnectionW = typedef std::weak_ptr<JsonapiConnection>;

---

typedef LoftPtr

A std::unique_ptr<> for Loft allocations.

using Ase::LoftPtr = typedef std::unique_ptr<T,LoftFree>;

---

enum LogFlags

Flags to configure logging behaviour.

enum Ase::LogFlags {
    LOG_FILE = 1,
    LOG_STDERR = 2,
    LOG_LOCATIONS = 4
};

---

typedef MainLoopP

typedef std::shared_ptr<MainLoop> Ase::MainLoopP;

---

typedef MidiDriverP

using Ase::MidiDriverP = typedef MidiDriver::MidiDriverP;

---

enum MidiEventType

Type of MIDI Events.

enum Ase::MidiEventType {
    PARAM_VALUE = 0x70,
    NOTE_OFF = 0x80,
    NOTE_ON = 0x90,
    AFTERTOUCH = 0xA0,
    CONTROL_CHANGE = 0xB0,
    PROGRAM_CHANGE = 0xC0,
    CHANNEL_PRESSURE = 0xD0,
    PITCH_BEND = 0xE0,
    SYSEX = 0xF0
};

---

enum MidiMessage

Extended type information for MidiEvent .

enum Ase::MidiMessage {
    NONE = 0,
    ALL_SOUND_OFF = 120,
    RESET_ALL_CONTROLLERS = 121,
    LOCAL_CONTROL = 122,
    ALL_NOTES_OFF = 123,
    OMNI_MODE_OFF = 124,
    OMNI_MODE_ON = 125,
    MONO_MODE_ON = 126,
    POLY_MODE_ON = 127,
    PARAM_VALUE = 0x70,
    NOTE_OFF = 0x80,
    NOTE_ON = 0x90,
    AFTERTOUCH = 0xA0,
    CONTROL_CHANGE = 0xB0,
    PROGRAM_CHANGE = 0xC0,
    CHANNEL_PRESSURE = 0xD0,
    PITCH_BEND = 0xE0,
    SYSEX = 0xF0
};

---

typedef MinMaxStep

Min, max, stepping for double ranges.

using Ase::MinMaxStep = typedef std::tuple<double,double,double>;

---

typedef MonitorImplP

using Ase::MonitorImplP = typedef std::shared_ptr<MonitorImpl>;

---

enum MusicalTuning

Musical tunings, see: http://en.wikipedia.org/wiki/Musical_tuning .

enum Ase::MusicalTuning {
    OD_12_TET,
    OD_7_TET,
    OD_5_TET,
    DIATONIC_SCALE,
    INDIAN_SCALE,
    PYTHAGOREAN_TUNING,
    PENTATONIC_5_LIMIT,
    PENTATONIC_BLUES,
    PENTATONIC_GOGO,
    QUARTER_COMMA_MEANTONE,
    SILBERMANN_SORGE,
    WERCKMEISTER_3,
    WERCKMEISTER_4,
    WERCKMEISTER_5,
    WERCKMEISTER_6,
    KIRNBERGER_3,
    YOUNG
};

---

enum OBusId

ID type for AudioProcessor output buses, buses are numbered with increasing index.

enum Ase::OBusId;

---

typedef ObjectImplP

using Ase::ObjectImplP = typedef std::shared_ptr<ObjectImpl>;

---

enum ParamId

ID type for AudioProcessor parameters, the ID numbers are user assignable.

enum Ase::ParamId;

---

typedef ParamInitialVal

Initial value for parameters.

using Ase::ParamInitialVal = typedef std::variant<bool,int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,int64_t,uint64_t,float,double,const char*,std::string>;

---

typedef ParameterC

using Ase::ParameterC = typedef std::shared_ptr<const Parameter>;

---

typedef PcmDriverP

using Ase::PcmDriverP = typedef PcmDriver::PcmDriverP;

---

typedef PollFDSourceP

typedef std::shared_ptr<PollFDSource> Ase::PollFDSourceP;

---

typedef PrefsMap

using Ase::PrefsMap = typedef std::unordered_map<CString,PrefsValue>;

---

typedef PrefsValueCallbackList

using Ase::PrefsValueCallbackList = typedef CallbackList<CString,const Value&>;

---

typedef ProjectImplP

using Ase::ProjectImplP = typedef std::shared_ptr<ProjectImpl>;

---

typedef PropertyGetter

Function type for Property value getters.

using Ase::PropertyGetter = typedef std::function<void (Value&)>;

---

typedef PropertyLister

Function type to list Choice __Property values.

using Ase::PropertyLister = typedef std::function<ChoiceS (const ParameterProperty&)>;

---

typedef PropertySetter

Function type for Property value setters.

using Ase::PropertySetter = typedef std::function<bool (const Value&)>;

---

typedef REQUIRES

REQUIRES<value> - Simplified version of std::enable_if<cond,bool>::type to use SFINAE in function templates.

using Ase::REQUIRES = typedef typename ::std::enable_if<value, bool>::type;

---

typedef REQUIRESv

REQUIRESv<value> - Simplified version of std::enable_if<cond,void>::type to use SFINAE in struct templates.

using Ase::REQUIRESv = typedef typename ::std::enable_if<value, void>::type;

---

enum RPath

enum Ase::RPath {
    PREFIXDIR = 1,
    INSTALLDIR,
    LOCALEDIR,
    LIBDIR,
    DEMODIR,
    LADSPADIRS
};

---

typedef RegisteredLoaderFunc

using Ase::RegisteredLoaderFunc = typedef Error (*) ();

---

typedef RegisteredLoaderVector

using Ase::RegisteredLoaderVector = typedef std::vector<RegisteredLoader>;

---

enum ResourceType

enum Ase::ResourceType {
    FOLDER = 1,
    FILE
};

---

enum SpeakerArrangement

enum Ase::SpeakerArrangement {
    NONE =           0,
    FRONT_LEFT =         0x1,
    FRONT_RIGHT =         0x2,
    FRONT_CENTER =         0x4,
    LOW_FREQUENCY =         0x8,
    BACK_LEFT =        0x10,
    BACK_RIGHT =        0x20,
    AUX = uint64_t (1) << 63,
    MONO = FRONT_LEFT,
    STEREO = FRONT_LEFT | FRONT_RIGHT,
    STEREO_21 = STEREO | LOW_FREQUENCY,
    STEREO_30 = STEREO | FRONT_CENTER,
    STEREO_31 = STEREO_30 | LOW_FREQUENCY,
    SURROUND_50 = STEREO_30 | BACK_LEFT | BACK_RIGHT,
    SURROUND_51 = SURROUND_50 | LOW_FREQUENCY
};

Flags to indicate channel arrangements of a bus. See also: https://en.wikipedia.org/wiki/Surround_sound

---

typedef StartQueue

using Ase::StartQueue = typedef AsyncBlockingQueue<char>;

---

typedef String

Convenience alias for std::string.

typedef std::string Ase::String;

---

typedef String3

using Ase::String3 = typedef std::tuple<String,String,String>;

---

typedef StringPair

using Ase::StringPair = typedef std::pair<std::string, std::string>;

---

typedef StringPairS

using Ase::StringPairS = typedef std::vector<std::tuple<String,String> >;

---

typedef StringS

Convenience alias for a std::vector<std::string>.

using Ase::StringS = typedef std::vector<String>;

---

typedef TYP

using Ase::TYP = typedef typename ::std::enable_if<std::is_same<T, C>::value, bool>::type;

---

typedef ThreadId

using Ase::ThreadId = typedef std::thread::id;

---

typedef TimedSourceP

typedef std::shared_ptr<TimedSource> Ase::TimedSourceP;

---

typedef USignalSourceP

typedef std::shared_ptr<USignalSource> Ase::USignalSourceP;

---

typedef ValueP

using Ase::ValueP = typedef std::shared_ptr<Value>;

---

typedef ValueVariant

Variant type to hold different types of values.

using Ase::ValueVariant = typedef std::variant<std::monostate,bool,int64,double,String,ValueS,ValueR,InstanceP>;

---

typedef VirtualBaseP

using Ase::VirtualBaseP = typedef std::shared_ptr<VirtualBase>;

---

typedef VoidF

using Ase::VoidF = typedef std::function<void()>;

---

typedef VoidFunc

using Ase::VoidFunc = typedef std::function<void()>;

---

typedef WaveWriterP

using Ase::WaveWriterP = typedef std::shared_ptr<WaveWriter>;

---

typedef WebSocketConnectionP

using Ase::WebSocketConnectionP = typedef std::shared_ptr<WebSocketConnection>;

---

typedef WebSocketServerImplP

using Ase::WebSocketServerImplP = typedef std::shared_ptr<WebSocketServerImpl>;

---

typedef WebSocketServerP

using Ase::WebSocketServerP = typedef std::shared_ptr<WebSocketServer>;

---

typedef WppConnection

using Ase::WppConnection = typedef WppConnectionP::element_type;

---

typedef WppConnectionP

using Ase::WppConnectionP = typedef WppServer::connection_ptr;

---

typedef WppHdl

using Ase::WppHdl = typedef websocketpp::connection_hdl;

---

typedef WppServer

using Ase::WppServer = typedef websocketpp::server<CustomServerConfig>;

---

typedef WritNodeS

using Ase::WritNodeS = typedef std::vector<WritNode>;

---

typedef WritP

using Ase::WritP = typedef std::shared_ptr<Writ>;

---

typedef int16

A 16-bit signed integer.

typedef int16_t Ase::int16;

---

typedef int32

A 32-bit signed integer.

typedef int32_t Ase::int32;

---

typedef int64

A 64-bit unsigned integer, use PRI*64 in format strings.

typedef int64_t Ase::int64;

---

typedef int8

An 8-bit signed integer.

typedef int8_t Ase::int8;

---

typedef uint

Provide 'uint' as convenience type.

typedef uint32_t Ase::uint;

---

typedef uint16

A 16-bit unsigned integer.

typedef uint16_t Ase::uint16;

---

typedef uint32

A 32-bit unsigned integer.

typedef uint32_t Ase::uint32;

---

typedef uint64

A 64-bit unsigned integer, use PRI*64 in format strings.

typedef uint64_t Ase::uint64;

---

typedef uint8

An 8-bit unsigned integer.

typedef uint8_t Ase::uint8;

---

typedef unichar

A 32-bit unsigned integer used for Unicode characters.

typedef uint32_t Ase::unichar;

---

Public Attributes Documentation

variable AUDIO_BLOCK_FLOAT_ZEROS_SIZE

Maximum number of values in the const_float_zeros block.

constexpr const uint Ase::AUDIO_BLOCK_FLOAT_ZEROS_SIZE;

---

variable App

const MainApp & Ase::App;

---

variable DOUBLE_EPSILON

Double round-off error at 1.0, equals 2^-53.

constexpr const double Ase::DOUBLE_EPSILON;

---

variable FIXED_N_CHANNELS

constexpr const uint Ase::FIXED_N_CHANNELS;

---

variable FIXED_N_MIDI_DRIVERS

constexpr const uint Ase::FIXED_N_MIDI_DRIVERS;

---

variable FIXED_SAMPLE_RATE

constexpr const uint Ase::FIXED_SAMPLE_RATE;

---

variable GUIONLY

GUI READABLE WRITABLE.

constexpr const char Ase::GUIONLY[];

---

variable INVERSE_SEMIQUAVER

constexpr double Ase::INVERSE_SEMIQUAVER;

---

variable MAX_BPM

constexpr const int64 Ase::MAX_BPM;

---

variable MAX_SAMPLERATE

constexpr const int64 Ase::MAX_SAMPLERATE;

---

variable MIDI_NOTE_ID_FIRST

First (internal) MIDI note event ID (lower IDs are reserved for external notes).

constexpr const uint Ase::MIDI_NOTE_ID_FIRST;

---

variable MIDI_NOTE_ID_LAST

Last valid (internal) MIDI note event ID.

constexpr const uint Ase::MIDI_NOTE_ID_LAST;

---

variable MIN_BPM

constexpr const int64 Ase::MIN_BPM;

---

variable MIN_SAMPLERATE

constexpr const int64 Ase::MIN_SAMPLERATE;

---

variable SEMIQUAVER_TICKS

constexpr const int64 Ase::SEMIQUAVER_TICKS;

---

variable SERVER

ServerImpl * Ase::SERVER;

---

variable STANDARD

STORAGE GUI READABLE WRITABLE.

constexpr const char Ase::STANDARD[];

---

variable STORAGE

STORAGE READABLE WRITABLE.

constexpr const char Ase::STORAGE[];

---

variable TRANSPORT_PPQN

Maximum number of sample frames to calculate in Processor::render().

constexpr const int64 Ase::TRANSPORT_PPQN;

---

variable __DEV__

constexpr const bool Ase::__DEV__;

---

variable __noreturn__

void Ase::__noreturn__;

---

variable args

const A & Ase::args;

---

variable ase_debugging_enabled

Global boolean to reduce debugging penalty where possible.

bool Ase::ase_debugging_enabled;

---

variable ase_fatal_warnings

Global boolean to cause the program to abort on warnings.

bool Ase::ase_fatal_warnings;

---

variable ase_gettext_domain

const char* const Ase::ase_gettext_domain;

---

variable ase_major_version

const int Ase::ase_major_version;

---

variable ase_micro_version

const int Ase::ase_micro_version;

---

variable ase_minor_version

const int Ase::ase_minor_version;

---

variable ase_sharedir

const char* const Ase::ase_sharedir;

---

variable ase_version_long

const char* const Ase::ase_version_long;

---

variable ase_version_short

const char* const Ase::ase_version_short;

---

variable assertion_failed_fatal

Global flag to force aborting on assertion warnings.

bool Ase::assertion_failed_fatal;

---

variable cached_hash_secret

Use hash_secret() for access.

uint64_t Ase::cached_hash_secret;

---

variable cent_table

Finetune factor table with 201 entries for -100…0…+100 cent.

const float *const Ase::cent_table;

---

variable columnline

uint64_t Ase::columnline;

---

variable const_float_zeros

Block of const floats allof value 0.

float Ase::const_float_zeros;

---

variable fileglob

bool const char* Ase::fileglob;

---

variable format

uint64_t const char const char* Ase::format;

---

variable func

uint64_t const char* Ase::func;

---

variable level

size_t Ase::level;

---

variable main_app

MainAppImpl Ase::main_app;

---

variable main_jobs

Execute a job callback in the Ase main loop.

JobQueue Ase::main_jobs;

---

variable main_loop

MainLoopP Ase::main_loop;

---

variable main_rt_jobs

Queue a callback for the main_loop without invoking malloc(), addition is obstruction free.

RtJobQueue Ase::main_rt_jobs;

---

variable maxbytes

bool const char const size_t Ase::maxbytes;

---

variable semitone_tables_265

Musical Tuning Tables, to be indexed by MusicalTuning __

const float *const Ase::semitone_tables_265;

---

variable size

size_t Ase::size;

---

variable speaker_arrangement_channels_mask

constexpr SpeakerArrangement Ase::speaker_arrangement_channels_mask;

---

variable unicode_last_codepoint

constexpr uint32_t Ase::unicode_last_codepoint;

---

Public Static Attributes Documentation

variable AUDIO_BLOCK_MAX_RENDER_SIZE

constexpr int64_t Ase::AUDIO_BLOCK_MAX_RENDER_SIZE;

---

variable D64MAX

constexpr double Ase::D64MAX;

---

variable F32EPS

constexpr float Ase::F32EPS;

---

variable F32MAX

constexpr float Ase::F32MAX;

---

variable I31MAX

constexpr int32_t Ase::I31MAX;

---

variable I31MIN

constexpr int32_t Ase::I31MIN;

---

variable I63MAX

constexpr int64_t Ase::I63MAX;

---

variable I63MIN

constexpr int64_t Ase::I63MIN;

---

variable KECCAK_RHO_OFFSETS

constexpr const uint8_t Ase::KECCAK_RHO_OFFSETS[25];

---

variable KECCAK_ROUND_CONSTANTS

constexpr const uint64_t Ase::KECCAK_ROUND_CONSTANTS[255];

---

variable M23MAX

constexpr float Ase::M23MAX;

---

variable M52MAX

constexpr double Ase::M52MAX;

---

variable MAX_LAUNCHER_CLIPS

constexpr const uint Ase::MAX_LAUNCHER_CLIPS;

---

variable MB

constexpr const size_t Ase::MB;

---

variable OUT1

constexpr OBusId Ase::OUT1;

---

variable PRINT_ADAPTIVE

constexpr bool Ase::PRINT_ADAPTIVE;

---

variable U32MAX

constexpr uint32_t Ase::U32MAX;

---

variable U64MAX

constexpr uint64_t Ase::U64MAX;

---

variable UNDEFINED_PRIORITY

const int16 Ase::UNDEFINED_PRIORITY;

---

variable all_projects

std::vector<ProjectImplP>& Ase::all_projects;

---

variable arg_class_tree

bool Ase::arg_class_tree;

---

variable arg_js_api

bool Ase::arg_js_api;

---

variable ase_linkid

const char* const Ase::ase_linkid;

---

variable atquit_funcs

std::vector<std::function<void()>*> Ase::atquit_funcs;

---

variable atquit_mutex

std::mutex Ase::atquit_mutex;

---

variable atquit_triggered_

std::atomic<uint8_t> Ase::atquit_triggered_;

---

variable audio_chain_id

const auto Ase::audio_chain_id;

---

variable audio_engine_thread_id

std::thread::id Ase::audio_engine_thread_id;

---

variable c3_hertz

constexpr const long double Ase::c3_hertz;

---

variable c3_hertz_inv

constexpr const long double Ase::c3_hertz_inv;

---

variable cached_application_name

String Ase::cached_application_name;

---

variable cached_program_alias

String Ase::cached_program_alias;

---

variable cachedirs_list

std::vector<String> Ase::cachedirs_list;

---

variable cachedirs_mutex

std::mutex Ase::cachedirs_mutex;

---

variable cent_table201

const float Ase::cent_table201[100+1+100];

---

variable check_test_names

StringS Ase::check_test_names;

---

variable clap_audio_wrapper_aseid

CString Ase::clap_audio_wrapper_aseid;

---

variable coalesce_notifies_head

CoalesceNotifies* Ase::coalesce_notifies_head;

---

variable cpu_info_jmp_buf

jmp_buf Ase::cpu_info_jmp_buf;

---

variable cstring_early_test

CString Ase::cstring_early_test;

---

variable current_message_conection

JsonapiConnectionP Ase::current_message_conection;

---

variable embedding_fd

int Ase::embedding_fd;

---

variable empty_event_output

const MidiEventOutput Ase::empty_event_output;

---

variable enotify_queue_head

std::atomic<AudioProcessor*> Ase::enotify_queue_head;

---

variable enotify_queue_tail

AudioProcessor* const Ase::enotify_queue_tail;

---

variable enuminfo_funcs

std::vector<std::pair<const std::type_info*, std::function<EnumInfo(int64)> > > Ase::enuminfo_funcs;

---

variable enuminfo_mutex

std::mutex Ase::enuminfo_mutex;

---

variable gadget_name_key

CustomDataKey<String> Ase::gadget_name_key;

---

variable global_id_counter

volatile int Ase::global_id_counter;

---

variable host_ext_audio_ports

const clap_host_audio_ports Ase::host_ext_audio_ports;

---

variable host_ext_file_reference

const clap_host_file_reference Ase::host_ext_file_reference;

---

variable host_ext_gui

const clap_host_gui Ase::host_ext_gui;

---

variable host_ext_log

const clap_host_log Ase::host_ext_log;

---

variable host_ext_params

const clap_host_params Ase::host_ext_params;

---

variable host_ext_posix_fd_support

const clap_host_posix_fd_support Ase::host_ext_posix_fd_support;

---

variable host_ext_thread_check

const clap_host_thread_check Ase::host_ext_thread_check;

---

variable host_ext_timer_support

const clap_host_timer_support Ase::host_ext_timer_support;

---

variable jsbin_logflags

constexpr int Ase::jsbin_logflags;

---

variable jsipc_logflags

constexpr int Ase::jsipc_logflags;

---

variable last_loft_preallocation

size_t Ase::last_loft_preallocation;

---

variable loft_needs_preallocation_mt

std::atomic<bool> Ase::loft_needs_preallocation_mt;

---

variable log_colorize

bool Ase::log_colorize;

---

variable log_fd

int Ase::log_fd;

---

variable log_flags

uint32_t Ase::log_flags;

---

variable main_rt_jobs_

AtomicIntrusiveStack<RtCallJob> Ase::main_rt_jobs_;

---

variable midi1_driver_pref

Preference Ase::midi1_driver_pref;

---

variable midi2_driver_pref

Preference Ase::midi2_driver_pref;

---

variable midi3_driver_pref

Preference Ase::midi3_driver_pref;

---

variable midi4_driver_pref

Preference Ase::midi4_driver_pref;

---

variable monotonic_clockid

clockid_t Ase::monotonic_clockid;

---

variable monotonic_resolution

uint64 Ase::monotonic_resolution;

---

variable monotonic_start

uint64 Ase::monotonic_start;

---

variable musical_tuning_info__

bool Ase::musical_tuning_info__;

---

variable mwc256_MP_SIZE

constexpr uint Ase::mwc256_MP_SIZE;

---

variable mwc256_mod

uint64_t Ase::mwc256_mod[mwc256_MP_SIZE];

---

variable next_noteid

std::atomic<uint> Ase::next_noteid;

---

variable notify_preference_queue

CStringS Ase::notify_preference_queue;

---

variable null_midi_driverid

const String Ase::null_midi_driverid;

---

variable null_pcm_driverid

const String Ase::null_pcm_driverid;

---

variable pcm_driver_pref

Preference Ase::pcm_driver_pref;

---

variable preferences_autosave

bool Ase::preferences_autosave;

---

variable prefs_callbacks

std::shared_ptr<CallbackList<CStringS> > Ase::prefs_callbacks;

---

variable programstart_timestamp

uint64 Ase::programstart_timestamp;

---

variable realtime_start

uint64 Ase::realtime_start;

---

variable registered_loaders_executed

bool Ase::registered_loaders_executed;

---

variable registry_first

std::atomic<const AudioProcessorRegistry*> Ase::registry_first;

---

variable scratch_float_buffer

float Ase::scratch_float_buffer[AUDIO_BLOCK_FLOAT_ZEROS_SIZE];

---

variable seen_autostop

std::atomic<bool> Ase::seen_autostop;

---

variable semitone_table265_diatonic_scale

const float Ase::semitone_table265_diatonic_scale[132+1+132];

---

variable semitone_table265_equal_temperament_12_tet

const float Ase::semitone_table265_equal_temperament_12_tet[132+1+132];

---

variable semitone_table265_equal_temperament_5_tet

const float Ase::semitone_table265_equal_temperament_5_tet[132+1+132];

---

variable semitone_table265_equal_temperament_7_tet

const float Ase::semitone_table265_equal_temperament_7_tet[132+1+132];

---

variable semitone_table265_indian_scale

const float Ase::semitone_table265_indian_scale[132+1+132];

---

variable semitone_table265_kirnberger_temperament

const float Ase::semitone_table265_kirnberger_temperament[132+1+132];

---

variable semitone_table265_pentatonic_5_limit

const float Ase::semitone_table265_pentatonic_5_limit[132+1+132];

---

variable semitone_table265_pentatonic_blues

const float Ase::semitone_table265_pentatonic_blues[132+1+132];

---

variable semitone_table265_pentatonic_gogo

const float Ase::semitone_table265_pentatonic_gogo[132+1+132];

---

variable semitone_table265_pythagorean_tuning

const float Ase::semitone_table265_pythagorean_tuning[132+1+132];

---

variable semitone_table265_quarter_comma_meantone

const float Ase::semitone_table265_quarter_comma_meantone[132+1+132];

---

variable semitone_table265_silbermann_sorge_temperament

const float Ase::semitone_table265_silbermann_sorge_temperament[132+1+132];

---

variable semitone_table265_werckmeister3_temperament

const float Ase::semitone_table265_werckmeister3_temperament[132+1+132];

---

variable semitone_table265_werckmeister4_temperament

const float Ase::semitone_table265_werckmeister4_temperament[132+1+132];

---

variable semitone_table265_werckmeister5_temperament

const float Ase::semitone_table265_werckmeister5_temperament[132+1+132];

---

variable semitone_table265_werckmeister6_temperament

const float Ase::semitone_table265_werckmeister6_temperament[132+1+132];

---

variable semitone_table265_young_temperament

const float Ase::semitone_table265_young_temperament[132+1+132];

---

variable subprotocol_authentication

String Ase::subprotocol_authentication;

---

variable synth_latency_pref

Preference Ase::synth_latency_pref;

---

variable synth_latency_pref

Preference Ase::synth_latency_pref;

---

variable task_registry_mutex_

std::mutex Ase::task_registry_mutex_;

---

variable task_registry_tasks_

TaskRegistry::List Ase::task_registry_tasks_;

---

variable telemetry_key

CustomDataKey<TelemetryPlanP> Ase::telemetry_key;

---

variable telemetry_size

constexpr size_t Ase::telemetry_size;

---

variable timerid_maybe_save_preferences

uint Ase::timerid_maybe_save_preferences;

---

variable user_note_id

std::atomic<uint> Ase::user_note_id;

---

variable usignals_notified

std::atomic<uint32> Ase::usignals_notified[8];

---

variable whitespaces

const char* Ase::whitespaces;

---

variable x11wrapper

Gtk2DlWrapEntry* Ase::x11wrapper;

---

variable zstd_adaptive_level

struct Ase Ase::zstd_adaptive_level[];

---

Public Functions Documentation

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ClapAudioProcessor
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ClapPluginHandleImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    AudioChain
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    AudioCombo
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    AudioEngineThread
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    AudioProcessor
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ClapDeviceImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ClapPluginHandle
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Clip
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ClipImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Device
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    DeviceImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Emittable
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    FileCrawler
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Gadget
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    GadgetImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Monitor
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    NativeDevice
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    NativeDeviceImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Object
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Preference
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Project
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ProjectImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Property
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    PropertyImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ResourceCrawler
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Server
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    ServerImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    SharedBase
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    StreamReader
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    StreamWriter
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Track
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    TrackImpl
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    Driver
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    MidiDriver
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    PcmDriver
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    EngineMidiInput
) 

---

function ASE_CLASS_DECLS

Ase::ASE_CLASS_DECLS (
    TelemetryPlan
) 

---

function ASE_DEFINE_ENUM_EQUALITY

Ase::ASE_DEFINE_ENUM_EQUALITY (
    Error
) 

---

function ASE_DEFINE_ENUM_EQUALITY

Ase::ASE_DEFINE_ENUM_EQUALITY (
    MusicalTuning
) 

---

function ASE_DEFINE_ENUM_EQUALITY

Ase::ASE_DEFINE_ENUM_EQUALITY (
    ParamId
) 

---

function ASE_DEFINE_ENUM_EQUALITY

Ase::ASE_DEFINE_ENUM_EQUALITY (
    IBusId
) 

---

function ASE_DEFINE_ENUM_EQUALITY

Ase::ASE_DEFINE_ENUM_EQUALITY (
    OBusId
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    AudioProcessorInfo
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    Choice
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    ClapParamUpdate
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    ClipNote
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    DeviceInfo
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    DriverEntry
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    Parameter
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    Resource
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    TelemetryField
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    TelemetrySegment
) 

---

function ASE_STRUCT_DECLS

Ase::ASE_STRUCT_DECLS (
    UserNote
) 

---

function QueueMultiplexer_priority

inline int Ase::QueueMultiplexer_priority (
    const MidiEvent & e
) 

---

function _

Translate message strings in the Anklang/ASE text domain.

const char *() Ase::_ (
    const char * string
) 

---

function _

Translate message strings in the Anklang/ASE text domain.

std::string() Ase::_ (
    const std::string & string
) 

---

function _

Translate message strings in the Anklang/ASE text domain, use @plural forms if != 1.

const char *() Ase::_ (
    const char * string,
    const char * plural,
    int64_t n
) 

---

function _

Translate message strings in the Anklang/ASE text domain, use @plural forms if != 1.

std::string() Ase::_ (
    const std::string & string,
    const std::string & plural,
    int64_t n
) 

---

function __attribute__

Call inplace new operator by automatically inferring the Type.

template<class Type, class ... Ts>
Ase::__attribute__ (
    (always_inline)
) 

---

function __attribute__

Call inplace delete operator by automatically inferring the Type.

template<class Type>
Ase::__attribute__ (
    (always_inline)
) 

---

function __attribute__

template<class ... Args>
Ase::__attribute__ (
    (noinline)
) 

Format a string according to an sprintf() format string with arguments. Refer to sprintf(3) for the format string details, this function is designed to serve as an sprintf() replacement and mimick its behaviour as close as possible. Supported format directive features are: * Formatting flags (sign conversion, padding, alignment), i.e. the flags: [-#0+ '] * Field width and precision specifications. * Positional arguments for field width, precision and value. * Length modifiers are tolerated: i.e. any of [hlLjztqZ]. * The conversion specifiers [spmcCdiouXxFfGgEeAa].

@NOTE Format errors, e.g. missing arguments will produce a warning on stderr and return the format string unmodified.

Returns:

A formatted string.

---

function __attribute__

template<class... A>
Ase::__attribute__ (
    (__noinline__)
) const

---

function __attribute__

template<class... A>
Ase::__attribute__ (
    (__always_inline__)
) const

---

function __format_arg__

const char *() Ase::__format_arg__ (
    2
) 

---

function anklang_cachedir_clean_stale

Clean stale cache directories from past runtimes, may be called from any thread.

void Ase::anklang_cachedir_clean_stale () 

---

function anklang_cachedir_cleanup

Cleanup a cachedir previously created with anklang_cachedir_create() .

void Ase::anklang_cachedir_cleanup (
    const String & cachedir
) 

---

function anklang_cachedir_create

Create exclusive cache directory for this process' runtime.

String Ase::anklang_cachedir_create () 

---

function anklang_home_dir

Get Anklang home dir, possibly adding subdir .

String Ase::anklang_home_dir (
    const String & subdir
) 

---

function anklang_runpath

Retrieve various resource paths at runtime.

std::string Ase::anklang_runpath (
    RPath rpath,
    const String & segment
) 

---

function application_name

Retrieve the localized program name intended for user display.

String Ase::application_name () 

---

function application_name_init

Set the application_name to a name other than program_alias if desired.

void Ase::application_name_init (
    String desktopname
) 

---

function ase_build_id

Provide a string containing the ASE library build id.

const char * Ase::ase_build_id () 

---

function ase_error_blurb

Describe Error condition.

const char * Ase::ase_error_blurb (
    Error error
) 

---

function ase_error_from_errno

Error Ase::ase_error_from_errno (
    int sys_errno,
    Error fallback=Error::IO
) 

---

function ase_gettext

const char * Ase::ase_gettext (
    const String & untranslated
) 

---

function ase_gettext

Translate a string, using the ASE locale.

template<class A0, class... Ar>
const char * Ase::ase_gettext (
    const char * format,
    const A0 & a0,
    const Ar &... restargs
) 

---

function ase_version

Provide a string containing the package version.

const char * Ase::ase_version () 

---

function assertion_failed

Print instructive message, handle "breakpoint", "backtrace" and "fatal-warnings" in $ASE_DEBUG.

void Ase::assertion_failed (
    const char * msg,
    const char * file,
    int line,
    const char * func
) noexcept

Issue a warning about an assertion error.

---

function assertion_fatal

Print a debug message via assertion_failed() and abort the program.

void Ase::assertion_fatal (
    const char * msg,
    const char * file,
    int line,
    const char * func
) noexcept

---

function atquit_add

void Ase::atquit_add (
    std::function< void()> * func
) 

---

function atquit_del

void Ase::atquit_del (
    std::function< void()> * func
) 

---

function atquit_run

void Ase::atquit_run (
    int exitcode
) 

---

function atquit_triggered

bool Ase::atquit_triggered () 

---

function backtrace_command

Find GDB and construct command line.

std::string Ase::backtrace_command () 

Command to start external debugger for a backtrace.

---

function blake3_hash_file

String Ase::blake3_hash_file (
    const String & filename
) 

---

function blake3_hash_string

String Ase::blake3_hash_string (
    const String & input
) 

---

function breakpoint

Cause a debugging breakpoint, for development only.

inline void Ase::breakpoint () 

---

function call_delete

Simple way to create a standalone callback to delete an object of type T .

template<class T>
void Ase::call_delete (
    T * o
) 

---

function clap_device_info

DeviceInfo Ase::clap_device_info (
    const ClapPluginDescriptor & descriptor
) 

---

function clap_event_to_string

String Ase::clap_event_to_string (
    const clap_event_note_t * enote
) 

---

function clap_event_type_string

const char * Ase::clap_event_type_string (
    int etype
) 

---

function collect_runtime_entropy

Collect entropy from the current process, usually quicker than collect_system_entropy() .

void Ase::collect_runtime_entropy (
    uint64 * data,
    size_t n
) 

To provide good quality random number seeds, this function gathers entropy from a variety of process specific sources. Under Linux, this includes the CPU counters, clocks and random devices. In combination with well established techniques like syscall timings (see Entropics13 Entropics13) and a SHA3 algorithm derived random number generator for the mixing, the entropy collection is designed to be fast and good enough for all non-cryptographic uses. On an Intel Core i7, this function takes around 25µs.

---

function collect_system_entropy

Collect entropy from system devices, like interrupt counters, clocks and random devices.

void Ase::collect_system_entropy (
    uint64 * data,
    size_t n
) 

This function adds to collect_runtime_entropy() by collecting entropy from aditional but potentially slower system sources, such as interrupt counters, disk + network statistics, system load, execution + pipelining + scheduling latencies and device MACs. The function is designed to yield random number seeds good enough to generate cryptographic tokens like session keys. On an Intel Core i7, this function takes around 2ms, so it's roughly 80 times slower than collect_runtime_entropy().

---

function constexpr_equals

Test string equality at compile time.

inline constexpr bool Ase::constexpr_equals (
    const char * a,
    const char * b,
    size_t n
) 

---

function convert_clip_samples

template<class S, class D>
inline void Ase::convert_clip_samples (
    size_t n,
    S * src,
    D * dst,
    uint16 byte_order
) 

---

function convert_clip_samples

template<>
inline void Ase::convert_clip_samples (
    size_t n,
    const float * src,
    int16_t * dst,
    uint16 byte_order
) 

---

function convert_samples

template<class S, class D>
inline void Ase::convert_samples (
    size_t n,
    S * src,
    D * dst,
    uint16 byte_order
) 

---

function convert_samples

template<>
inline void Ase::convert_samples (
    size_t n,
    const int16_t * src,
    float * dst,
    uint16 byte_order
) 

---

function cpu_arch

Retrieve string identifying the CPU architecture.

std::string Ase::cpu_arch () 

---

function cpu_info

Retrieve string identifying the runtime CPU type.

String Ase::cpu_info () 

The returned string contains: number of online CPUs, a string describing the CPU architecture, the vendor and finally a number of flag words describing CPU features plus a trailing space. This allows checks for CPU features via a simple string search for " FEATURE ".

Returns:

Example: "4 AMD64 GenuineIntel FPU TSC HTT CMPXCHG16B MMX MMXEXT SSESYS SSE SSE2 SSE3 SSSE3 SSE4.1 SSE4.2 "

---

function create_processor_device

DeviceP Ase::create_processor_device (
    AudioEngine & engine,
    const String & uri,
    bool engineproducer
) 

---

function cstring_to_bool

bool Ase::cstring_to_bool (
    const char * string,
    bool fallback
) 

---

function cstrings_to_vector

Construct a StringS from a NULL terminated list of string arguments.

StringS Ase::cstrings_to_vector (
    const char * s,
    ...
) 

---

function current_locale_strtold

Parse a double from a string ala strtod(), trying locale specific characters and POSIX/C formatting.

long double Ase::current_locale_strtold (
    const char * nptr,
    char ** endptr
) 

---

function damerau_levenshtein_distance

float Ase::damerau_levenshtein_distance (
    const std::string & source,
    const std::string & target,
    const float ci,
    const float cd,
    const float cs,
    const float ct
) 

Damerau-Levenshtein Distance with unrestricted transpositions. Calculate the unrestricted Damerau-Levenshtein string distance with quadratic time complexity and quadratic memory requirement. Memory: 4 * |source|*|target| + constant.

---

function damerau_levenshtein_restricted

float Ase::damerau_levenshtein_restricted (
    const std::string & source,
    const std::string & target,
    const float ci,
    const float cd,
    const float cs,
    const float ct
) 

Damerau-Levenshtein Distance with restricted transposition. Calculate the restricted Damerau-Levenshtein string distance with quadratic time complexity and linear memory requirement. Memory: 12 * max(|source|,|target|) + constant.

---

function db2voltage

Convert Decibel to synthesizer value (Voltage).

template<typename Float>
inline Float Ase::db2voltage (
    Float x
) 

---

function db2voltage

Convert Decibel to synthesizer value (Voltage).

template<typename Float>
inline ASE_CONST Float Ase::db2voltage (
    Float x
) 

---

function db_changed

Determine a significant Decibel change.

template<typename Float>
inline Float Ase::db_changed (
    Float a,
    Float b
) 

---

function db_changed

Determine a significant Decibel change.

template<typename Float>
inline ASE_CONST Float Ase::db_changed (
    Float a,
    Float b
) 

---

function debug

template<class ... A>
void Ase::debug (
    const char * cond,
    const char * format,
    const A &... args
) 

---

function debug

Issue a printf-like debugging message if cond is enabled by $ASE_DEBUG.

template<class ... Args>
inline void ASE_ALWAYS_INLINE Ase::debug (
    const char * cond,
    const char * format,
    const Args &... args
) 

---

function debug_enabled

Check if any kind of debugging is enabled by $ASE_DEBUG.

inline bool Ase::debug_enabled () 

---

function debug_key_enabled

Check if conditional is enabled by $ASE_DEBUG.

bool Ase::debug_key_enabled (
    const char * conditional
) 

---

function debug_key_enabled

Check if conditional is enabled by $ASE_DEBUG.

bool Ase::debug_key_enabled (
    const ::std::string & conditional
) 

---

function debug_key_enabled

bool Ase::debug_key_enabled (
    const std::string & conditional
) 

---

function debug_key_value

Retrieve the value assigned to debug key conditional in $ASE_DEBUG.

::std::string Ase::debug_key_value (
    const char * conditional
) 

---

function debug_message

Print a debug message, called from Ase::debug().

void Ase::debug_message (
    const char * cond,
    const std::string & message
) 

---

function decodefs

Decode UTF-8 string back into file system path representation, extracting surrogate code points as bytes.

std::string Ase::decodefs (
    const std::string & utf8str
) 

---

function diag_flush

Handle stdout and stderr printing with flushing.

void Ase::diag_flush (
    uint8 code,
    const String & txt
) 

---

function diag_prefix

Create prefix for warnings and errors.

String Ase::diag_prefix (
    uint8 code
) 

---

function displayfs

Convert UTF-8 encoded file system path into human readable display format, the conversion is lossy but readable.

std::string Ase::displayfs (
    const std::string & utf8str
) 

---

function encodefs

Encode a file system path consisting of bytes into UTF-8, using surrogate code points to store non UTF-8 bytes.

std::string Ase::encodefs (
    const std::string & fschars
) 

---

function enum_lister

Helper to list Jsonipc::Enum<> type values as Choice .

template<typename Enum>
ChoiceS Ase::enum_lister (
    const ParameterProperty &
) 

---

function executable_name

Retrieve the name part of executable_path() .

std::string Ase::executable_name () 

---

function executable_path

Retrieve the path to the currently running executable.

std::string Ase::executable_path () 

---

function fast_copy

Copy a block of floats.

inline void Ase::fast_copy (
    size_t n,
    float * d,
    const float * s
) 

---

function fast_copy

Copy a block of integers.

inline void Ase::fast_copy (
    size_t n,
    uint32_t * d,
    const uint32_t * s
) 

---

function fast_db2voltage

Float precision variant of db2voltage using fast_exp2() .

inline float Ase::fast_db2voltage (
    float x
) 

---

function fast_exp2

inline float Ase::fast_exp2 (
    float x
) 

Fast approximation of 2 raised to the power of x. The parameter x is the exponent within [-127.0…+127.0]. Within -1…+1, the error stays below 4e-7 which corresponds to a sample precision of 21 bit. For integer values of x (i.e. x - floor (x) -> 0), the error approaches zero. With FMA instructions and -ffast-math enabled, execution times should be below 10ns on 3GHz machines.

---

function fast_hz2voltage

Float precision variant of hz2voltage using fast_log2() .

inline float Ase::fast_hz2voltage (
    float x
) 

---

function fast_log2

inline float Ase::fast_log2 (
    float x
) 

Fast approximation of logarithm to base 2. The parameter x is the exponent within [1.1e-38…2^127]. Within 1e-7…+1, the error stays below 3.8e-6 which corresponds to a sample precision of 18 bit. When x is an exact power of 2, the error approaches zero. With FMA instructions and -ffast-math enabled, execution times should be below 10ns on 3GHz machines.

---

function fast_mem_alloc

void * Ase::fast_mem_alloc (
    size_t size
) 

---

function fast_mem_free

void Ase::fast_mem_free (
    void * mem
) 

---

function fast_voltage2db

Float precision variant of voltage2db using fast_log2() .

inline float Ase::fast_voltage2db (
    float x
) 

---

function fast_voltage2hz

Float precision variant of voltage2hz using fast_exp2() .

inline float Ase::fast_voltage2hz (
    float x
) 

---

function fatal_error

template<class ... A>
void Ase::fatal_error (
    const char * format,
    const A &... args
) 

---

function fatal_error

template<class ... Args>
void ASE_NORETURN Ase::fatal_error (
    const char * format,
    const Args &... args
) 

Issue a printf-like message and abort the program, this function will not return. Avoid using this in library code, aborting may take precious user data with it, library code should instead use warning(), info() or assert_return().

---

function fatal_system_error

void Ase::fatal_system_error (
    const char * file,
    uint line,
    const char * format,
    ...
) 

---

function find_shared_by_ref

template<typename E>
std::pair< std::shared_ptr< E >, ssize_t > Ase::find_shared_by_ref (
    const std::vector< std::shared_ptr< E > > & v,
    const E & e
) 

---

function fixed_sort

Use sorting networks to sort containers <= 16 elements without allocations.

template<class RandomIt, class Compare>
inline void Ase::fixed_sort (
    RandomIt first,
    RandomIt last,
    Compare comp=std::less< typename std::iterator_traits< RandomIt >::value_type >()
) 

---

function floatfill

Fill n values ofdst withf .

inline void Ase::floatfill (
    float * dst,
    float f,
    size_t n
) 

---

function force_double

Force number into double precision floating point format, even with -ffast-math .

inline double Ase::force_double (
    double d
) 

---

function force_float

Force number into single precision floating point format, even with -ffast-math .

inline float Ase::force_float (
    float f
) 

---

function hz2value

Convert Hertz to synthesizer value (Voltage).

inline float Ase::hz2value (
    float x
) 

---

function hz2voltage

Convert Hertz to synthesizer value (Voltage).

template<typename Float>
inline Float Ase::hz2voltage (
    Float x
) 

---

function hz2voltage

Convert Hertz to synthesizer value (Voltage).

template<typename Float>
inline ASE_CONST Float Ase::hz2voltage (
    Float x
) 

---

function hz_changed

Determine a significant frequency change (audible Hertz).

template<typename Float>
inline Float Ase::hz_changed (
    Float a,
    Float b
) 

---

function hz_changed

Determine a significant frequency change (audible Hertz).

template<typename Float>
inline ASE_CONST Float Ase::hz_changed (
    Float a,
    Float b
) 

---

function irintf

inline ASE_CONST int Ase::irintf (
    float f
) 

Round float to int, using round-to-nearest Fast version of f < 0 ? int (f - 0.5) : int (f + 0.5).

---

function is_aiff

bool Ase::is_aiff (
    const String & input
) 

---

function is_arj

bool Ase::is_arj (
    const String & input
) 

---

function is_avi

bool Ase::is_avi (
    const String & input
) 

---

function is_compressed

bool Ase::is_compressed (
    const String & input
) 

---

function is_gz

bool Ase::is_gz (
    const String & input
) 

---

function is_isz

bool Ase::is_isz (
    const String & input
) 

---

function is_jpg

bool Ase::is_jpg (
    const String & input
) 

---

function is_lz4

bool Ase::is_lz4 (
    const String & input
) 

---

function is_midi

bool Ase::is_midi (
    const String & input
) 

---

function is_ogg

bool Ase::is_ogg (
    const String & input
) 

---

function is_pdf

bool Ase::is_pdf (
    const String & input
) 

---

function is_png

bool Ase::is_png (
    const String & input
) 

---

function is_wav

bool Ase::is_wav (
    const String & input
) 

---

function is_xz

bool Ase::is_xz (
    const String & input
) 

---

function is_zip

bool Ase::is_zip (
    const String & input
) 

---

function is_zstd

bool Ase::is_zstd (
    const String & input
) 

---

function json_parse

Parse a well formed JSON string and assign contents to target .

template<class T>
inline bool Ase::json_parse (
    const String & jsonstring,
    T & target
) 

---

function json_parse

Parse a well formed JSON string and return the resulting value.

template<class T>
inline T Ase::json_parse (
    const String & jsonstring
) 

---

function json_stringify

Create JSON string from source .

template<class T>
inline String Ase::json_stringify (
    const T & source,
    Writ::Flags flags=Writ::Flags(0)
) 

---

function jsonapi_connection_data

CustomDataContainer * Ase::jsonapi_connection_data () 

---

function jsonapi_connection_sender

JsonapiBinarySender Ase::jsonapi_connection_sender () 

---

function jsonapi_make_connection

WebSocketConnectionP Ase::jsonapi_make_connection (
    WebSocketConnection::Internals & internals,
    int logflags
) 

---

function jsonapi_require_auth

void Ase::jsonapi_require_auth (
    const String & subprotocol
) 

---

function kvpair_key

String Ase::kvpair_key (
    const String & key_value_pair
) 

---

function kvpair_value

String Ase::kvpair_value (
    const String & key_value_pair
) 

---

function kvpairs_assign

bool Ase::kvpairs_assign (
    StringS & kvs,
    const String & key_value_pair,
    bool casesensitive
) 

---

function kvpairs_fetch

String Ase::kvpairs_fetch (
    const StringS & kvs,
    const String & key,
    bool casesensitive
) 

---

function kvpairs_search

ssize_t Ase::kvpairs_search (
    const StringS & kvs,
    const String & k,
    const bool casesensitive
) 

---

function list_clap_files

StringS Ase::list_clap_files () 

---

function load_registered_drivers

Load all registered drivers.

void Ase::load_registered_drivers () 

---

function loft_make_unique

Construct an object T fromLoft memory, wrapped in a unique_ptr.

template<class T, class ... Args>
inline LoftPtr < T > Ase::loft_make_unique (
    Args &&... args
) 

---

function log

Write a log message to the log file (or possibly stderr), using the POSIX/C locale.

template<class... A>
void Ase::log (
    const LogFormat & format,
    const A &... args
) 

---

function log_setup

Configurable handler to open log files.

LogFlags Ase::log_setup (
    int * logfd
) 

---

function logmsg

void Ase::logmsg (
    const std::string & msg,
    const char *const filename,
    const uint64_t columnline,
    const char *const function_name
) 

---

function main_jobs

JobQueue Ase::main_jobs (
    call_main_loop
) 

---

function main_loop_autostop_mt

void Ase::main_loop_autostop_mt () 

---

function main_loop_wakeup

void Ase::main_loop_wakeup () 

---

function make_aftertouch

MidiEvent Ase::make_aftertouch (
    uint16 chnl,
    uint8 mkey,
    float velo,
    float tune,
    uint nid
) 

---

function make_audio_engine

AudioEngine & Ase::make_audio_engine (
    const VoidF & owner_wakeup,
    uint sample_rate,
    SpeakerArrangement speakerarrangement
) 

---

function make_control

MidiEvent Ase::make_control (
    uint16 chnl,
    uint prm,
    float val
) 

---

function make_control8

MidiEvent Ase::make_control8 (
    uint16 chnl,
    uint prm,
    uint8 cval
) 

---

function make_enum_getter

Value getter for enumeration types.

template<typename Enum>
std::function< void( Value &)> Ase::make_enum_getter (
    Enum * v
) 

---

function make_enum_setter

Value setter for enumeration types.

template<typename Enum>
std::function< bool(const Value &)> Ase::make_enum_setter (
    Enum * v
) 

---

function make_note_off

MidiEvent Ase::make_note_off (
    uint16 chnl,
    uint8 mkey,
    float velo,
    float tune,
    uint nid
) 

---

function make_note_on

MidiEvent Ase::make_note_on (
    uint16 chnl,
    uint8 mkey,
    float velo,
    float tune,
    uint nid
) 

---

function make_param_value

MidiEvent Ase::make_param_value (
    uint param,
    double pvalue
) 

---

function make_pitch_bend

MidiEvent Ase::make_pitch_bend (
    uint16 chnl,
    float val
) 

---

function make_pressure

MidiEvent Ase::make_pressure (
    uint16 chnl,
    float velo
) 

---

function make_program

MidiEvent Ase::make_program (
    uint16 chnl,
    uint prgrm
) 

---

function memset4

Fill a memory area with a 32-bit quantitiy.

void Ase::memset4 (
    uint32 * mem,
    uint32 filler,
    uint length
) 

---

function monotonic_counter

A monotonically increasing counter, increments are atomic and visible in all threads.

uint64 Ase::monotonic_counter () 

---

function now_strftime

String Ase::now_strftime (
    const String & format
) 

---

function operator!

constexpr bool Ase::operator! (
    Error error
) 

---

function operator+=

Convenience ChoiceS construciton helper.

ChoiceS & Ase::operator+= (
    ChoiceS & choices,
    Choice && newchoice
) 

---

function operator==

inline bool Ase::operator== (
    const std::vector< ValueP > & v1,
    const std::vector< ValueP > & v2
) 

---

function operator|

inline constexpr Re::Flags Ase::operator| (
    Re::Flags a,
    Re::Flags b
) 

---

function parameter_guess_nick

Create a few letter nick name from a multi word parameter label.

String Ase::parameter_guess_nick (
    const String & parameter_label
) 

Find a suitable 3-letter abbreviation for a Parameter without nick.

---

function posix_locale_strtold

Parse a double from a string ala strtod(), trying locale specific characters and POSIX/C formatting.

long double Ase::posix_locale_strtold (
    const char * nptr,
    char ** endptr
) 

---

function printerr

template<class... A>
void void Ase::printerr (
    const char * format,
    const A &... args
) 

---

function printerr

Print a message on stderr (and flush stderr) ala printf(), using the POSIX/C locale.

template<class... Args>
void Ase::printerr (
    const char * format,
    const Args &... args
) 

---

function printout

template<class... A>
void Ase::printout (
    const char * format,
    const A &... args
) 

---

function printout

Print a message on stdout (and flush stdout) ala printf(), using the POSIX/C locale.

template<class... Args>
void Ase::printout (
    const char * format,
    const Args &... args
) 

---

function program_alias

Retrieve the program name as used for logging or debug messages.

String Ase::program_alias () 

---

function program_alias_init

Set program_alias to a non-localized alias other than program_argv0 if desired.

void Ase::program_alias_init (
    String customname
) 

---

function program_cwd

The current working directory during startup.

String Ase::program_cwd () 

---

function random_float

double Ase::random_float () 

Generate uniformly distributed pseudo-random floating point number. This function generates a pseudo-random number like random_int64(), constrained to the range: 0.0 <= number < 1.0.

---

function random_frange

double Ase::random_frange (
    double begin,
    double end
) 

Generate uniformly distributed pseudo-random floating point number within a range. This function generates a pseudo-random number like random_float(), constrained to the range: begin <= number < end.

---

function random_int64

uint64_t Ase::random_int64 () 

Generate a non-deterministic, uniformly distributed 64 bit pseudo-random number. This function generates pseudo-random numbers using the system state as entropy and class KeccakRng for the mixing. No seeding is required.

---

function random_irange

int64_t Ase::random_irange (
    int64_t begin,
    int64_t end
) 

Generate uniformly distributed pseudo-random integer within range. This function generates a pseudo-random number like random_int64(), constrained to the range: begin <= number < end.

---

function random_nonce

Provide a unique 64 bit identifier that is not 0, see also random_int64() .

uint64_t Ase::random_nonce () 

---

function random_secret

Generate a secret non-zero nonce in secret_var, unless it has already been assigned.

void Ase::random_secret (
    uint64_t * secret_var
) 

---

function register_audio_processor

Add an AudioProcessor derived type to the audio processor registry.

template<typename T>
inline CString Ase::register_audio_processor (
    const char * aseid=nullptr
) 

---

function register_driver_loader

Register loader callbacks at static constructor time.

bool * Ase::register_driver_loader (
    const char * staticwhat,
    Error (*)() loader
) 

---

function sched_fast_priority

Try to acquire low latency scheduling priority, returns true if nice level is < 0.

bool Ase::sched_fast_priority (
    int tid
) 

---

function sched_get_priority

Retrieve the nice level of process or thread tid .

int Ase::sched_get_priority (
    int tid
) 

---

function sched_set_priority

Try to set the nice level of process or thread tid tonicelevel .

bool Ase::sched_set_priority (
    int tid,
    int nicelevel
) 

---

function sha3_224_hash

Calculate 224 bit SHA3 digest from data , see also classSHA3_224 .

void Ase::sha3_224_hash (
    const void * data,
    size_t data_length,
    uint8_t hashvalue
) 

---

function sha3_256_hash

Calculate 256 bit SHA3 digest from data , see also classSHA3_256 .

void Ase::sha3_256_hash (
    const void * data,
    size_t data_length,
    uint8_t hashvalue
) 

---

function sha3_384_hash

Calculate 384 bit SHA3 digest from data , see also classSHA3_384 .

void Ase::sha3_384_hash (
    const void * data,
    size_t data_length,
    uint8_t hashvalue
) 

---

function sha3_512_hash

Calculate 512 bit SHA3 digest from data , see also classSHA3_512 .

void Ase::sha3_512_hash (
    const void * data,
    size_t data_length,
    uint8_t hashvalue
) 

---

function shake128_hash

Calculate SHA3 extendable output digest for 128 bit security strength, see also class SHAKE128 .

void Ase::shake128_hash (
    const void * data,
    size_t data_length,
    uint8_t * hashvalues,
    size_t n
) 

---

function shake256_hash

Calculate SHA3 extendable output digest for 256 bit security strength, see also class SHAKE256 .

void Ase::shake256_hash (
    const void * data,
    size_t data_length,
    uint8_t * hashvalues,
    size_t n
) 

---

function shared_ptr_cast

template<class Target, class Source>
std::shared_ptr< typename std::remove_pointer< Target >::type > Ase::shared_ptr_cast (
    Source * object
) 

Shorthand for std::dynamic_pointer_cast<>(shared_from_this()). A shared_ptr_cast() takes a std::shared_ptr or a pointer to an object that supports std::enable_shared_from_this::shared_from_this(). Using std::dynamic_pointer_cast(), the shared_ptr passed in (or retrieved via calling shared_from_this()) is cast into a std::shared_ptr<Target>, possibly resulting in an empty (NULL) std::shared_ptr if the underlying dynamic_cast() was not successful or if a NULL object was passed in. Note that shared_from_this() can throw a std::bad_weak_ptr exception if the object has no associated std::shared_ptr (usually during ctor and dtor), in which case the exception will also be thrown from shared_ptr_cast<Target>(). However a shared_ptr_cast<Target*>() call will not throw and yield an empty (NULL) std::shared_ptr<Target>. This is analogous to dynamic_cast<T@amp> which throws, versus dynamic_cast<T*> which yields NULL.

Returns:

A std::shared_ptr<Target> storing a pointer to object or NULL.

Exception:

• std::bad_weak_ptr if shared_from_this() throws, unless the Target* form is used.

---

function shared_ptr_cast

See shared_ptr_cast(Source*) .

template<class Target, class Source>
const std::shared_ptr< typename std::remove_pointer< Target >::type > Ase::shared_ptr_cast (
    const Source * object
) 

---

function shared_ptr_cast

See shared_ptr_cast(Source*) .

template<class Target, class Source>
std::shared_ptr< typename std::remove_pointer< Target >::type > Ase::shared_ptr_cast (
    std::shared_ptr< Source > & sptr
) 

---

function shared_ptr_cast

See shared_ptr_cast(Source*) .

template<class Target, class Source>
const std::shared_ptr< typename std::remove_pointer< Target >::type > Ase::shared_ptr_cast (
    const std::shared_ptr< Source > & sptr
) 

---

function shared_ptr_from

Use shared_ptr_cast<>() to convert an object pointer into ashared_ptr<> .

template<class Source>
std::shared_ptr< typename std::remove_pointer< Source >::type > Ase::shared_ptr_from (
    Source * object
) 

---

function speaker_arrangement_bit_name

const char * Ase::speaker_arrangement_bit_name (
    SpeakerArrangement spa
) 

---

function speaker_arrangement_channels

SpeakerArrangement Ase::speaker_arrangement_channels (
    SpeakerArrangement spa
) 

---

function speaker_arrangement_count_channels

uint8 Ase::speaker_arrangement_count_channels (
    SpeakerArrangement spa
) 

---

function speaker_arrangement_desc

std::string Ase::speaker_arrangement_desc (
    SpeakerArrangement spa
) 

---

function speaker_arrangement_is_aux

bool Ase::speaker_arrangement_is_aux (
    SpeakerArrangement spa
) 

---

function square_max

Find the maximum suqared value in a block of floats.

float Ase::square_max (
    uint n_values,
    const float * ivalues
) 

---

function square_sum

Calculate suqare sum of a block of floats.

float Ase::square_sum (
    uint n_values,
    const float * ivalues
) 

---

function stream_reader_from_file

StreamReaderP Ase::stream_reader_from_file (
    const String & file
) 

---

function stream_reader_zip_member

StreamReaderP Ase::stream_reader_zip_member (
    const String & archive,
    const String & member,
    Storage::StorageFlags f
) 

---

function stream_reader_zstd

StreamReaderP Ase::stream_reader_zstd (
    StreamReaderP & istream
) 

---

function stream_writer_create_file

StreamWriterP Ase::stream_writer_create_file (
    const String & filename,
    int mode
) 

---

function stream_writer_zstd

StreamWriterP Ase::stream_writer_zstd (
    const StreamWriterP & ostream,
    int level
) 

---

function strerror

Get POSIX locale strerror.

const char * Ase::strerror (
    int errno_num
) 

---

function strerror

const char * Ase::strerror () 

---

function string_canonify

String Ase::string_canonify (
    const String & string,
    const String & valid_chars,
    const String & substitute
) 

Enforce a canonical charset for a string. Convert all chars in string that are not listed as valid_chars with substitute.

---

function string_capitalize

Capitalize words, so the first letter is upper case, the rest lower case.

String Ase::string_capitalize (
    const String & str,
    size_t maxn,
    bool rest_tolower
) 

---

function string_casecmp

Like strcasecmp(3) for UTF-8 strings.

int Ase::string_casecmp (
    const String & s1,
    const String & s2
) 

---

function string_casefold

Yield UTF-8 string useful for case insensitive comparisons.

String Ase::string_casefold (
    const String & src
) 

---

function string_cmp

Like strcmp(3) for UTF-8 strings.

int Ase::string_cmp (
    const String & s1,
    const String & s2
) 

---

function string_cmp_uuid

Returns whether uuid_string1 compares smaller (-1), equal (0) or greater (+1) to__uuid_string2 .

int Ase::string_cmp_uuid (
    const String & uuid_string1,
    const String & uuid_string2
) 

---

function string_demangle_cxx

Demangle identifier via libcc.

const char * Ase::string_demangle_cxx (
    const char * mangled_identifier
) noexcept

Demangle a std::typeinfo.name() string into a proper C++ type name. This function uses abi::__cxa_demangle() from <cxxabi.h> to demangle C++ type names, which works for g++, libstdc++, clang++, libc++.

---

function string_endswith

Returns whether string ends withfragment .

bool Ase::string_endswith (
    const String & string,
    const String & fragment
) 

---

function string_endswith

Returns whether string ends with any element offragments .

bool Ase::string_endswith (
    const String & string,
    const StringS & fragments
) 

---

function string_find_word

Find occurance of word inhaystack .

const char * Ase::string_find_word (
    const char * haystack,
    const char * word
) 

---

function string_format

Format a string similar to sprintf(3) with support for std::string and std::ostringstream convertible objects.

template<class ... Args>
std::string Ase::string_format (
    const char * format,
    const Args &... args
) 

---

function string_from_bool

Convert a boolean value into a string.

String Ase::string_from_bool (
    bool value
) 

---

function string_from_cquote

Parse a possibly quoted C string into regular string.

String Ase::string_from_cquote (
    const String & input
) 

---

function string_from_double

Convert a double into a string, using the POSIX/C locale.

String Ase::string_from_double (
    double value
) 

---

function string_from_double_vector

Construct a string out of all double values passed in dvec , separated by__delim .

String Ase::string_from_double_vector (
    const std::vector< double > & dvec,
    const String & delim
) 

---

function string_from_errno

Returns a String describing the passed in errno value, similar to strerror().

String Ase::string_from_errno (
    int errno_val
) 

---

function string_from_float

Convert a float into a string, using the POSIX/C locale.

String Ase::string_from_float (
    float value
) 

---

function string_from_float

inline String Ase::string_from_float (
    double value
) 

---

function string_from_int

Convert a 64bit signed integer into a string.

String Ase::string_from_int (
    int64 value
) 

---

function string_from_long_double

Convert a long double into a string, using the POSIX/C locale.

String Ase::string_from_long_double (
    long double value
) 

---

function string_from_pretty_function_name

String Ase::string_from_pretty_function_name (
    const char * cxx_pretty_function
) 

Extract the full function name from PRETTY_FUNCTION. See also ASE_SIMPLE_FUNCTION.

---

function string_from_type

Create a string from a templated argument value, such as bool, int, double.

template<typename Type>
String Ase::string_from_type (
    Type value
) 

---

function string_from_type< String >

template<>
inline String Ase::string_from_type< String > (
    String value
) 

---

function string_from_type< bool >

template<>
inline String Ase::string_from_type< bool > (
    bool value
) 

---

function string_from_type< double >

template<>
inline String Ase::string_from_type< double > (
    double value
) 

---

function string_from_type< float >

template<>
inline String Ase::string_from_type< float > (
    float value
) 

---

function string_from_type< int >

template<>
inline String Ase::string_from_type< int > (
    int value
) 

---

function string_from_type< int16 >

template<>
inline String Ase::string_from_type< int16 > (
    int16 value
) 

---

function string_from_type< int64 >

template<>
inline String Ase::string_from_type< int64 > (
    int64 value
) 

---

function string_from_type< long double >

template<>
inline String Ase::string_from_type< long double > (
    long double value
) 

---

function string_from_type< uint >

template<>
inline String Ase::string_from_type< uint > (
    uint value
) 

---

function string_from_type< uint16 >

template<>
inline String Ase::string_from_type< uint16 > (
    uint16 value
) 

---

function string_from_type< uint64 >

template<>
inline String Ase::string_from_type< uint64 > (
    uint64 value
) 

---

function string_from_uint

Convert a 64bit unsigned integer into a string.

String Ase::string_from_uint (
    uint64 value
) 

---

function string_has_int

Checks if a string contains a digit, optionally preceeded by whitespaces.

bool Ase::string_has_int (
    const String & string
) 

---

function string_hexdump

String Ase::string_hexdump (
    const void * addr,
    size_t length,
    size_t initial_offset
) 

Produce hexdump of a memory region. Each output line consists of its hexadecimal offset, 16 hexadecimal bytes and the ASCII representation of the same 16 bytes.

---

function string_is_ascii_alnum

bool Ase::string_is_ascii_alnum (
    const String & str
) 

---

function string_is_canonified

Check if string_canonify() would modify__string .

bool Ase::string_is_canonified (
    const String & string,
    const String & valid_chars
) 

---

function string_is_ncname

bool Ase::string_is_ncname (
    const String & input
) 

Check input to be a NCName, according to the QName EBNF. See https://en.wikipedia.org/wiki/QName

---

function string_is_uuid

Returns whether uuid_string contains a properly formatted UUID string.

bool Ase::string_is_uuid (
    const String & uuid_string
) 

---

function string_islower

Check if all string characters are Unicode lower case characters.

bool Ase::string_islower (
    const String & str
) 

---

function string_isupper

Check if all string characters are Unicode upper case characters.

bool Ase::string_isupper (
    const String & str
) 

---

function string_join

String Ase::string_join (
    const String & junctor,
    const StringS & strvec
) 

Join a number of strings. Join a string vector into a single string, using junctor inbetween each pair of strings.

---

function string_locale_vprintf

Formatted printing like string_vprintf using the current locale.

String Ase::string_locale_vprintf (
    const char * format,
    va_list vargs
) 

---

function string_lstrip

Strip whitespaces from the left of a string.

String Ase::string_lstrip (
    const String & input
) 

---

function string_match_identifier

Check equality of strings canonicalized to "[0-9a-z_]+".

bool Ase::string_match_identifier (
    const String & ident1,
    const String & ident2
) 

---

function string_match_identifier_tail

Variant of string_match_identifier() that matches__tail against__ident at word boundary.

bool Ase::string_match_identifier_tail (
    const String & ident,
    const String & tail
) 

---

function string_multiply

Reproduce a string s for__count times.

String Ase::string_multiply (
    const String & s,
    uint64 count
) 

---

function string_normalize_nfc

Yield normalized composed UTF-8 string.

String Ase::string_normalize_nfc (
    const String & src
) 

---

function string_normalize_nfd

Yield normalized decomposed UTF-8 string.

String Ase::string_normalize_nfd (
    const String & src
) 

---

function string_normalize_nfkc

Formatting stripped normalized composed UTF-8 string.

String Ase::string_normalize_nfkc (
    const String & src
) 

---

function string_normalize_nfkd

Formatting stripped normalized decomposed UTF-8 string.

String Ase::string_normalize_nfkd (
    const String & src
) 

---

function string_option_check

Check if an option is set/unset in an options list string.

bool Ase::string_option_check (
    const String & optionlist,
    const String & feature
) 

---

function string_option_find

Retrieve the option value from an options list separated by ':' or ';' or fallback .

String Ase::string_option_find (
    const String & optionlist,
    const String & feature,
    const String & fallback
) 

---

function string_option_find_value

Low level option search, avoids dynamic allocations.

std::string_view Ase::string_option_find_value (
    const char * string,
    const char * feature,
    const String & fallback,
    const String & denied,
    bool matchallnone
) 

---

function string_replace

Replace substring marker in__input with__replacement , at most__maxn times.

String Ase::string_replace (
    const String & input,
    const String & marker,
    const String & replacement,
    size_t maxn
) 

---

function string_rstrip

Strip whitespaces from the right of a string.

String Ase::string_rstrip (
    const String & input
) 

---

function string_set_A2Z

Returns a string containing all of A-Z.

const String & Ase::string_set_A2Z () 

---

function string_set_a2z

Returns a string containing all of a-z.

const String & Ase::string_set_a2z () 

---

function string_set_ascii_alnum

Returns a string containing all of 0-9, A-Z and a-z.

const String & Ase::string_set_ascii_alnum () 

---

function string_split

StringS Ase::string_split (
    const String & string,
    const String & splitter,
    size_t maxn
) 

Split a string, using splitter as delimiter. Passing "" as splitter will split the string at whitespace positions.

---

function string_split_any

StringS Ase::string_split_any (
    const String & string,
    const String & splitchars,
    size_t maxn
) 

Split a string, using any of the splitchars as delimiter. Passing "" as splitter will split the string between all position.

---

function string_startswith

Returns whether string starts withfragment .

bool Ase::string_startswith (
    const String & string,
    const String & fragment
) 

---

function string_startswith

Returns whether string starts with any element offragments .

bool Ase::string_startswith (
    const String & string,
    const StringS & fragments
) 

---

function string_strip

Strip whitespaces from the left and right of a string.

String Ase::string_strip (
    const String & input
) 

---

function string_substitute_char

Replace all occouranes of match in__input with__subst .

String Ase::string_substitute_char (
    const String & input,
    const char match,
    const char subst
) 

---

function string_to_bool

bool Ase::string_to_bool (
    const String & string,
    bool fallback
) 

Interpret a string as boolean value. Interpret the string as number, "ON"/"OFF" or distinguish "false"/"true" or "yes"/"no" by starting letter. For empty strings, fallback is returned.

---

function string_to_cescape

String Ase::string_to_cescape (
    const String & str
) 

Escape text like a C string. Returns a string that escapes all characters with a backslash '\' that need escaping in C language string syntax.

---

function string_to_cquote

Returns a string as C string including double quotes.

String Ase::string_to_cquote (
    const String & str
) 

---

function string_to_double

Parse a double from a string, trying locale specific characters and POSIX/C formatting.

double Ase::string_to_double (
    const String & string
) 

---

function string_to_double

Similar to string_to_double(const String&) , but returns the first failing character position in__endptr .

double Ase::string_to_double (
    const char * dblstring,
    const char ** endptr
) 

---

function string_to_double_vector

Parse a string into a list of doubles, expects ';' as delimiter.

std::vector< double > Ase::string_to_double_vector (
    const String & string
) 

---

function string_to_float

inline double Ase::string_to_float (
    const String & string
) 

---

function string_to_hex

Convert bytes in string input to hexadecimal numbers.

String Ase::string_to_hex (
    const String & input
) 

---

function string_to_identifier

Force lower case, alphanumerics + underscore and non-digit start.

String Ase::string_to_identifier (
    const String & input
) 

---

function string_to_int

Parse a string into a 64bit integer, optionally specifying the expected number base.

int64 Ase::string_to_int (
    const String & string,
    size_t * consumed,
    uint base
) 

---

function string_to_long_double

Parse a long double from a string, trying locale specific characters and POSIX/C formatting.

long double Ase::string_to_long_double (
    const String & string
) 

---

function string_to_long_double

Similar to string_to_long_double(const String&) , but returns the first failing character position in__endptr .

long double Ase::string_to_long_double (
    const char * dblstring,
    const char ** endptr
) 

---

function string_to_ncname

String Ase::string_to_ncname (
    const String & input,
    uint32_t substitute
) 

Convert input to a NCName, according to the QName EBNF. See https://en.wikipedia.org/wiki/QName

---

function string_to_seconds

Parse string into seconds.

double Ase::string_to_seconds (
    const String & string,
    double fallback
) 

---

function string_to_type

Convert a string to template argument type, such as bool, int, double.

template<typename Type>
Type Ase::string_to_type (
    const String & string
) 

---

function string_to_type< String >

template<>
inline String Ase::string_to_type< String > (
    const String & string
) 

---

function string_to_type< bool >

template<>
inline bool Ase::string_to_type< bool > (
    const String & string
) 

---

function string_to_type< double >

template<>
inline double Ase::string_to_type< double > (
    const String & string
) 

---

function string_to_type< float >

template<>
inline float Ase::string_to_type< float > (
    const String & string
) 

---

function string_to_type< int >

template<>
inline int Ase::string_to_type< int > (
    const String & string
) 

---

function string_to_type< int16 >

template<>
inline int16 Ase::string_to_type< int16 > (
    const String & string
) 

---

function string_to_type< int64 >

template<>
inline int64 Ase::string_to_type< int64 > (
    const String & string
) 

---

function string_to_type< long double >

template<>
inline long double Ase::string_to_type< long double > (
    const String & string
) 

---

function string_to_type< uint >

template<>
inline uint Ase::string_to_type< uint > (
    const String & string
) 

---

function string_to_type< uint16 >

template<>
inline uint16 Ase::string_to_type< uint16 > (
    const String & string
) 

---

function string_to_type< uint64 >

template<>
inline uint64 Ase::string_to_type< uint64 > (
    const String & string
) 

---

function string_to_uint

Parse a string into a 64bit unsigned integer, optionally specifying the expected number base.

uint64 Ase::string_to_uint (
    const String & string,
    size_t * consumed,
    uint base
) 

---

function string_tolower

Convert all string characters into Unicode lower case characters.

String Ase::string_tolower (
    const String & str
) 

---

function string_totitle

Convert all string characters into Unicode title characters.

String Ase::string_totitle (
    const String & str
) 

---

function string_toupper

Convert all string characters into Unicode upper case characters.

String Ase::string_toupper (
    const String & str
) 

---

function string_url_decode

Decode URL %-sequences in a string, decode '+' if form_url_encoded .

String Ase::string_url_decode (
    const String & urlstr,
    const bool form_url_encoded
) 

---

function string_url_encode

Encode special characters to URL %-sequences, encode space as '+' if form_url_encoded .

String Ase::string_url_encode (
    const String & rawstr,
    const bool form_url_encoded
) 

---

function string_vector_erase_empty

Remove empty elements from a string vector.

void Ase::string_vector_erase_empty (
    StringS & svector
) 

---

function string_vector_find

String Ase::string_vector_find (
    const StringS & svector,
    const String & prefix,
    const String & fallback
) 

Search for prefix in svector and return the matching element. If multiple matches are possible, the last one is returned.

Returns:

fallback if no match was found.

---

function string_vector_find_value

String Ase::string_vector_find_value (
    const StringS & svector,
    const String & prefix,
    const String & fallback
) 

Search for prefix in svector and return reminder of the matching string. If multiple matches are possible, the last one is returned.

Returns:

fallback if no match was found.

---

function string_vector_lstrip

Left-strip all elements of a string vector, see string_lstrip() .

void Ase::string_vector_lstrip (
    StringS & svector
) 

---

function string_vector_rstrip

Right-strip all elements of a string vector, see string_rstrip() .

void Ase::string_vector_rstrip (
    StringS & svector
) 

---

function string_vector_strip

Strip all elements of a string vector, see string_strip() .

void Ase::string_vector_strip (
    StringS & svector
) 

---

function string_vprintf

Formatted printing ala vprintf() into a String, using the POSIX/C locale.

String Ase::string_vprintf (
    const char * format,
    va_list vargs
) 

---

function stringify_clip_note

String Ase::stringify_clip_note (
    const ClipNote & n
) 

---

function strings_version_sort

StringS Ase::strings_version_sort (
    const StringS & strings,
    bool reverse
) 

---

function strings_version_sort

void Ase::strings_version_sort (
    StringS * strings,
    bool reverse
) 

---

function strrstr

const char * Ase::strrstr (
    const char * haystack,
    const char * needle
) 

---

function telemetry_field

template<class T>
inline TelemetryField Ase::telemetry_field (
    const String & name,
    const T * field
) 

---

function text_convert

bool Ase::text_convert (
    const String & to_charset,
    String & output_string,
    const String & from_charset,
    const String & input_string,
    const String & fallback_charset,
    const String & output_mark
) 

Convert a string from one encoding to another. Convert input_string from encoding from_charset to to_charset, returning output_string. Interpret unknown characters according to fallback_charset. Use output_mark in place of unconvertible characters. Returns whether the conversion was successful.

---

function this_thread_get_name

String Ase::this_thread_get_name () 

---

function this_thread_getpid

int Ase::this_thread_getpid () 

---

function this_thread_gettid

int Ase::this_thread_gettid () 

---

function this_thread_is_ase

inline bool Ase::this_thread_is_ase () 

---

function this_thread_online_cpus

int Ase::this_thread_online_cpus () 

---

function this_thread_self

ThreadId Ase::this_thread_self () 

---

function this_thread_set_name

void Ase::this_thread_set_name (
    const String & name16chars
) 

---

function timestamp_benchmark

Returns benchmark timestamp in nano-seconds, clock starts around program startup.

uint64 Ase::timestamp_benchmark () 

---

function timestamp_format

Convert stamp into a string, adding µsecond fractions if space permits.

String Ase::timestamp_format (
    uint64 stamp,
    uint maxlength
) 

---

function timestamp_now

Current time in µseconds.

uint64_t Ase::timestamp_now () 

---

function timestamp_realtime

Return the current time as uint64 in µseconds.

uint64 Ase::timestamp_realtime () 

---

function timestamp_resolution

Provide resolution of timestamp_benchmark() in nano-seconds.

uint64 Ase::timestamp_resolution () 

---

function timestamp_startup

Provides the timestamp_realtime() value from program startup.

uint64 Ase::timestamp_startup () 

---

function uint16_swap_le_be

Swap 16-Bit integers between __BIG_ENDIAN and __LITTLE_ENDIAN systems.

inline constexpr uint16_t Ase::uint16_swap_le_be (
    uint16_t v
) 

---

function uint32_swap_le_be

Swap 32-Bit integers between __BIG_ENDIAN and __LITTLE_ENDIAN systems.

inline constexpr uint32_t Ase::uint32_swap_le_be (
    uint32_t v
) 

---

function uint64_swap_le_be

Swap 64-Bit integers between __BIG_ENDIAN and __LITTLE_ENDIAN systems.

inline constexpr uint64_t Ase::uint64_swap_le_be (
    uint64_t v
) 

---

function unicode_is_assigned

Return whether u matches any of the assigned Unicode planes.

inline constexpr bool Ase::unicode_is_assigned (
    uint32_t u
) 

---

function unicode_is_character

Return whether u is not one of the 66 Unicode noncharacters.

inline constexpr bool Ase::unicode_is_character (
    uint32_t u
) 

---

function unicode_is_control_code

Return whether u is one of the 65 Unicode control codes.

inline constexpr bool Ase::unicode_is_control_code (
    uint32_t u
) 

---

function unicode_is_noncharacter

Return whether u is one of the 66 Unicode noncharacters.

inline constexpr bool Ase::unicode_is_noncharacter (
    uint32_t u
) 

---

function unicode_is_private

Return whether u is in one of the 3 private use areas of Unicode.

inline constexpr bool Ase::unicode_is_private (
    uint32_t u
) 

---

function unicode_is_valid

Return whether u is an allowed Unicode codepoint within 0x10FFFF and not part of a UTF-16 surrogate pair.

inline constexpr bool Ase::unicode_is_valid (
    uint32_t u
) 

---

function user_id

int Ase::user_id () 

---

function user_name

String Ase::user_name () 

---

function user_real_name

String Ase::user_real_name () 

---

function utf8_to_unicode

size_t Ase::utf8_to_unicode (
    const char * str,
    uint32_t * codepoints
) 

Convert valid UTF-8 sequences to Unicode codepoints, invalid sequences are treated as Latin-1 characters. The array codepoints must be able to hold at least as many elements as are characters stored in str. Returns the number of codepoints stored in codepoints.

---

function utf8_to_unicode

size_t Ase::utf8_to_unicode (
    const std::string & str,
    std::vector< uint32_t > & codepoints
) 

Convert valid UTF-8 sequences to Unicode codepoints, invalid sequences are treated as Latin-1 characters. Returns the number of codepoints newly stored in codepoints.

---

function utf8decode

Convert valid UTF-8 sequences to Unicode codepoints, invalid sequences are treated as Latin-1 characters.

std::vector< uint32_t > Ase::utf8decode (
    const std::string & utf8str
) 

---

function utf8encode

Convert codepoints into an UTF-8 string, using the shortest possible encoding.

std::string Ase::utf8encode (
    const uint32_t * codepoints,
    size_t n_codepoints
) 

---

function utf8encode

Convert codepoints into an UTF-8 string, using the shortest possible encoding.

std::string Ase::utf8encode (
    const std::vector< uint32_t > & codepoints
) 

---

function utf8len

Count valid UTF-8 sequences, invalid sequences are counted as Latin-1 characters.

size_t Ase::utf8len (
    const char * str
) 

---

function utf8len

Count valid UTF-8 sequences, invalid sequences are counted as Latin-1 characters.

size_t Ase::utf8len (
    const std::string & str
) 

---

function value2hz

Convert synthesizer value (Voltage) to Hertz.

inline float Ase::value2hz (
    float x
) 

---

function voltage2db

Convert synthesizer value (Voltage) to Decibel.

template<typename Float>
inline Float Ase::voltage2db (
    Float x
) 

---

function voltage2db

Convert synthesizer value (Voltage) to Decibel.

template<typename Float>
inline ASE_CONST Float Ase::voltage2db (
    Float x
) 

---

function voltage2hz

Convert synthesizer value (Voltage) to Hertz.

template<typename Float>
inline Float Ase::voltage2hz (
    Float x
) 

---

function voltage2hz

Convert synthesizer value (Voltage) to Hertz.

template<typename Float>
inline ASE_CONST Float Ase::voltage2hz (
    Float x
) 

---

function voltage_changed

Determine a significant synthesizer value (Voltage) change.

template<typename Float>
inline Float Ase::voltage_changed (
    Float a,
    Float b
) 

---

function voltage_changed

Determine a significant synthesizer value (Voltage) change.

template<typename Float>
inline ASE_CONST Float Ase::voltage_changed (
    Float a,
    Float b
) 

---

function warning

template<class ... A>
void Ase::warning (
    const char * format,
    const A &... args
) 

---

function warning

Issue a printf-like warning message.

template<class ... Args>
void Ase::warning (
    const char * format,
    const Args &... args
) 

---

function wave_writer_create_flac

WaveWriterP Ase::wave_writer_create_flac (
    int rate,
    int channels,
    const String & filename,
    int mode,
    int compresion
) 

---

function wave_writer_create_opus

WaveWriterP Ase::wave_writer_create_opus (
    int rate,
    int channels,
    const String & filename,
    int mode,
    int complexity,
    float bitrate
) 

---

function wave_writer_create_wav

WaveWriterP Ase::wave_writer_create_wav (
    int rate,
    int channels,
    const String & filename,
    int mode,
    uint8_t n_bits
) 

---

function wave_writer_flac_version

String Ase::wave_writer_flac_version () 

---

function wave_writer_opus_version

String Ase::wave_writer_opus_version () 

---

function weak_ptr_fetch_or_create

Fetch shared_ptr fromwptr and createC withctor if needed.

template<class C>
std::shared_ptr< C > Ase::weak_ptr_fetch_or_create (
    std::weak_ptr< C > & wptr,
    const std::function< std::shared_ptr< C >()> & ctor
) 

---

function zintern_decompress

uint8 * Ase::zintern_decompress (
    unsigned int decompressed_size,
    const unsigned char * cdata,
    unsigned int cdata_size
) 

Decompress data via zlib.

Parameters:

• decompressed_size exact size of the decompressed data to be returned
• cdata compressed data block
• cdata_size exact size of the compressed data block

Returns:

decompressed data block or NULL in low memory situations

Decompress the data from cdata of length cdata_size into a newly allocated block of size decompressed_size which is returned. The returned block needs to be released with zintern_free(). This function is intended to decompress data which has been compressed with the packres.py utility, so no errors should occour during decompression. Consequently, if any error occours during decompression or if the resulting data block is of a size other than decompressed_size, the program will abort with an appropriate error message. If not enough memory could be allocated for decompression, NULL is returned.

---

function zintern_free

Free data returned from zintern_decompress() .

void Ase::zintern_free (
    uint8 * dc_data
) 

---

function zstd_compress

String Ase::zstd_compress (
    const String & input,
    int level
) 

---

function zstd_compress

String Ase::zstd_compress (
    const void * src,
    size_t src_size,
    int level
) 

---

function zstd_target_size

ssize_t Ase::zstd_target_size (
    const String & input
) 

---

function zstd_uncompress

ssize_t Ase::zstd_uncompress (
    const String & input,
    void * dst,
    size_t dst_size
) 

---

function zstd_uncompress

String Ase::zstd_uncompress (
    const String & input
) 

---

Public Static Functions Documentation

function __attribute__

static bool Ase::__attribute__ (
    (__unused__)
) 

---

function __attribute__

static void Ase::__attribute__ (
    (__noinline__)
) 

---

function access_clap_plugin

static const clap_plugin * Ase::access_clap_plugin (
    ClapPluginHandle * handle
) 

---

function aliased_iconv_open

static iconv_t Ase::aliased_iconv_open (
    const String & tocode,
    const String & fromcode
) 

---

function alloc_id

static uint Ase::alloc_id () 

---

function anklang_cachedir_base

Find base directory for the creation of temporary caches.

static String Ase::anklang_cachedir_base (
    bool createbase=false
) 

---

function anklang_host_name

static const char * Ase::anklang_host_name () 

---

function apply_driver_preferences

static void Ase::apply_driver_preferences () 

---

function assertion_abort

static void Ase::assertion_abort (
    const char * msg,
    const char * file,
    int line,
    const char * func
) noexcept

---

function atexit_clean_cachedirs

Clean temporary caches of this process.

static void Ase::atexit_clean_cachedirs () 

---

function atomic_next_ptrref

static inline std::atomic< EngineJobImpl * > & Ase::atomic_next_ptrref (
    EngineJobImpl * j
) 

---

function atomic_next_ptrref

static inline std::atomic< AudioEngineThread::UserNoteJob * > & Ase::atomic_next_ptrref (
    AudioEngineThread::UserNoteJob * j
) 

---

function atomic_next_ptrref

static inline std::atomic< RtCallJob * > & Ase::atomic_next_ptrref (
    RtCallJob * j
) 

---

function bit_rotate64

Rotate left for uint64_t.

static inline uint64_t Ase::bit_rotate64 (
    uint64_t bits,
    unsigned int offset
) 

---

function byte_hash64

Fast byte hashing with good dispersion and runtime randomization.

template<class Num>
static inline ASE_CONST uint64_t Ase::byte_hash64 (
    const Num * data,
    size_t length
) 

---

function c_isalnum

static inline bool Ase::c_isalnum (
    uint8 c
) 

---

function call_main_loop

static void Ase::call_main_loop (
    const std::function< void()> & fun
) 

---

function choice_from_driver_entry

static Choice Ase::choice_from_driver_entry (
    const DriverEntry & e,
    const String & icon_keywords
) 

---

function clapid

static String Ase::clapid (
    const clap_host * host
) 

---

function cml_set

static auto & Ase::cml_set () 

---

function codepoint_is_namestartchar

static bool Ase::codepoint_is_namestartchar (
    uint32_t c
) 

Check c to be a NameStartChar, according to the QName EBNF. See https://en.wikipedia.org/wiki/QName

---

function codepoint_is_ncname

static bool Ase::codepoint_is_ncname (
    uint32_t c
) 

Check c to be a NameChar, according to the QName EBNF. See https://en.wikipedia.org/wiki/QName

---

function construct_ladspa_path

static std::string Ase::construct_ladspa_path () 

---

function cpu_info_sigill_handler

static void ASE_NORETURN Ase::cpu_info_sigill_handler (
    int dummy
) 

---

function current_locale_vprintf

static inline String Ase::current_locale_vprintf (
    const char * format,
    va_list vargs
) 

---

function current_user

static const PwdUser & Ase::current_user () 

---

function damerau_levenshtein_unrestricted

static float Ase::damerau_levenshtein_unrestricted (
    const std::string_view & source,
    const std::string_view & target,
    const float ci,
    const float cd,
    const float cs,
    const float ct
) 

---

function determine_anklangsynthengine_installdir

static std::string Ase::determine_anklangsynthengine_installdir (
    bool * using_objdir
) 

---

function dispatch_loft_lowmem

static bool Ase::dispatch_loft_lowmem (
    const Ase::LoopState & lstate
) 

---

function divmod

Compute integers division and modulo with one X86 asm instruction.

template<typename T>
static inline constexpr T Ase::divmod (
    T dividend,
    T divisor,
    T * reminderp
) 

---

function error_result

static Blob Ase::error_result (
    String url,
    int fallback_errno=EINVAL,
    String msg="failed to load"
) 

---

function event_unions_try_push

static bool Ase::event_unions_try_push (
    ClapEventUnionS & events,
    const clap_event_header_t * event
) 

---

function feature_canonify

static String Ase::feature_canonify (
    const String & str
) 

---

function find_anklang_parent_dir

static String Ase::find_anklang_parent_dir (
    const String & path
) 

---

function find_option

static const char * Ase::find_option (
    const char * haystack,
    const char *const needle,
    const size_t l,
    const int allowoption
) 

---

function find_text_file

Find the binary file containing the runtime symbol at symbol_address .

static std::string Ase::find_text_file (
    ptrdiff_t symbol_address
) 

---

function flags_to_pcre2_compile_options

static uint32_t Ase::flags_to_pcre2_compile_options (
    Re::Flags flags
) 

---

function fnv1a_consthash64

template<class Num>
static inline constexpr uint64_t Ase::fnv1a_consthash64 (
    const Num * ztdata
) 

Simple, very fast and well known hash function as constexpr with good dispersion. This is the 64bit version of the well known FNV-1a hash function, implemented as a C++11 constexpr for zero-terminated strings, so the hashes can be used e.g. as case labels in switch statements.

---

function fnv1a_consthash64

Variant of fnv1a_consthash64() for memory blocks of arbitrary size.

template<class Num>
static inline constexpr uint64_t Ase::fnv1a_consthash64 (
    const Num *const data,
    size_t length
) 

---

function get_arc4random

static void Ase::get_arc4random (
    uint64 * u,
    uint count
) 

---

function get_arch_name

static const char * Ase::get_arch_name (
    void
) 

---

function get_executable_path

static std::string Ase::get_executable_path () 

---

function get_pwd_user

static PwdUser Ase::get_pwd_user (
    int uid
) 

---

function get_rdrand

static bool Ase::get_rdrand (
    uint64 * u,
    uint count
) 

---

function get_x86_cpu_features

static bool Ase::get_x86_cpu_features (
    CPUInfo * ci
) 

---

function getenv_ase_debug

static const char * Ase::getenv_ase_debug () 

---

function getrandom

static int Ase::getrandom (
    void * buffer,
    size_t count,
    unsigned flags
) 

---

function global_random64

static uint64_t Ase::global_random64 () 

---

function guess_zstd_level

static int Ase::guess_zstd_level (
    size_t input_size
) 

---

function handle_autostop

static bool Ase::handle_autostop (
    const LoopState & state
) 

---

function handle_ptr

static ClapPluginHandleImpl * Ase::handle_ptr (
    const clap_host * host
) 

---

function handle_sptr

static ClapPluginHandleImplP Ase::handle_sptr (
    const clap_host * host
) 

---

function has_debug_key

Quick boolean check for a colon separated key in a haystack.

static bool Ase::has_debug_key (
    const char *const debugkeys,
    const char *const key
) 

---

function hash_anything

template<class Data>
static void Ase::hash_anything (
    KeccakRng & pool,
    const Data & data
) 

---

function hash_cpu_usage

static void Ase::hash_cpu_usage (
    KeccakRng & pool
) 

---

function hash_file

static bool Ase::hash_file (
    KeccakRng & pool,
    const char * filename,
    const size_t maxbytes=16384
) 

---

function hash_getrandom

static bool Ase::hash_getrandom (
    KeccakRng & pool
) 

---

function hash_macs

static bool Ase::hash_macs (
    KeccakRng & pool
) 

---

function hash_secret

Provide hashing nonce for reseeding hashes at program start to avoid collision attacks.

static inline ASE_PURE uint64_t Ase::hash_secret () 

---

function hash_stat

static bool Ase::hash_stat (
    KeccakRng & pool,
    const char * filename
) 

---

function hash_sys_structs

static void Ase::hash_sys_structs (
    KeccakRng & pool
) 

---

function host_call_on_timer

static bool Ase::host_call_on_timer (
    ClapPluginHandleImplP handlep,
    clap_id timer_id
) 

---

function host_file_reference_changed

static void Ase::host_file_reference_changed (
    const clap_host_t * host
) 

---

function host_file_reference_set_dirty

static void Ase::host_file_reference_set_dirty (
    const clap_host_t * host,
    clap_id resource_id
) 

---

function host_get_extension_mt

static const void * Ase::host_get_extension_mt (
    const clap_host * host,
    const char * extension_id
) 

---

function host_gui_closed

static void Ase::host_gui_closed (
    const clap_host_t * host,
    bool was_destroyed
) 

---

function host_gui_create_x11_window

static ulong Ase::host_gui_create_x11_window (
    ClapPluginHandleImplP handlep,
    int width,
    int height
) 

---

function host_gui_delete_request

static void Ase::host_gui_delete_request (
    ClapPluginHandleImplP handlep
) 

---

function host_is_audio_thread

static bool Ase::host_is_audio_thread (
    const clap_host_t * host
) 

---

function host_is_main_thread

static bool Ase::host_is_main_thread (
    const clap_host_t * host
) 

---

function host_is_rescan_flag_supported

static bool Ase::host_is_rescan_flag_supported (
    const clap_host_t * host,
    uint32_t flag
) 

---

function host_log

static void Ase::host_log (
    const clap_host_t * host,
    clap_log_severity severity,
    const char * msg
) 

---

function host_modify_fd

static bool Ase::host_modify_fd (
    const clap_host_t * host,
    int fd,
    clap_posix_fd_flags_t flags
) 

---

function host_params_clear

static void Ase::host_params_clear (
    const clap_host_t * host,
    clap_id param_id,
    clap_param_clear_flags flags
) 

---

function host_params_rescan

static void Ase::host_params_rescan (
    const clap_host_t * host,
    clap_param_rescan_flags flags
) 

---

function host_register_fd

static bool Ase::host_register_fd (
    const clap_host_t * host,
    int fd,
    clap_posix_fd_flags_t flags
) 

---

function host_register_timer

static bool Ase::host_register_timer (
    const clap_host * host,
    uint32_t period_ms,
    clap_id * timer_id
) 

---

function host_request_callback_mt

static void Ase::host_request_callback_mt (
    const clap_host * host
) 

---

function host_request_flush

static void Ase::host_request_flush (
    const clap_host_t * host
) 

---

function host_request_hide

static bool Ase::host_request_hide (
    const clap_host_t * host
) 

---

function host_request_process_mt

static void Ase::host_request_process_mt (
    const clap_host * host
) 

---

function host_request_resize

static bool Ase::host_request_resize (
    const clap_host_t * host,
    uint32_t width,
    uint32_t height
) 

---

function host_request_restart_mt

static void Ase::host_request_restart_mt (
    const clap_host * host
) 

---

function host_request_show

static bool Ase::host_request_show (
    const clap_host_t * host
) 

---

function host_rescan

static void Ase::host_rescan (
    const clap_host_t * host,
    uint32_t flag
) 

---

function host_resize_hints_changed

static void Ase::host_resize_hints_changed (
    const clap_host_t * host
) 

---

function host_unregister_fd

static bool Ase::host_unregister_fd (
    const clap_host_t * host,
    int fd
) 

---

function host_unregister_timer

static bool Ase::host_unregister_timer (
    const clap_host * host,
    clap_id timer_id
) 

---

function identifier_char_canon

static inline char Ase::identifier_char_canon (
    char c
) 

---

function identifier_match

static inline bool Ase::identifier_match (
    const char * str1,
    const char * str2
) 

---

function init_sigpipe

static void Ase::init_sigpipe () 

---

function initialized_ase_gettext_domain

Initialize gettext domain for ASE.

static const char * Ase::initialized_ase_gettext_domain () 

---

function interleaved_stereo

template<int ADDING>
static void Ase::interleaved_stereo (
    const size_t n_frames,
    float * buffer,
    AudioProcessor & proc,
    OBusId obus
) 

---

function is_anklang_dir

static bool Ase::is_anklang_dir (
    const String & path
) 

---

function is_localhost

static bool Ase::is_localhost (
    const String & url,
    int port
) 

---

function is_separator

static bool Ase::is_separator (
    char c
) 

---

function libc_strtold

static long double Ase::libc_strtold (
    const char * nptr,
    char ** endptr
) 

---

function logstart

static void Ase::logstart () 

---

function main_rt_jobs_pending

static bool Ase::main_rt_jobs_pending () 

---

function main_rt_jobs_process

static void Ase::main_rt_jobs_process () 

---

function make_anklang_dir

static bool Ase::make_anklang_dir (
    const String & path
) 

---

function make_auth_string

static String Ase::make_auth_string () 

---

function make_case_table

template<std::size_t LAST, typename MkFun>
static auto Ase::make_case_table (
    const MkFun & mkjump
) 

Create a jump table std::array<Fun,LAST>, where Fun is returned from mkjump (0 … LAST). Note, mkjump(auto) is a lambda template, invoked with std::integral_constant<unsigned long, 0…LAST>.

---

function make_dispatcher

static Jsonipc::IpcDispatcher * Ase::make_dispatcher () 

---

function make_indexed_table

Create a std::array<Fun,N> , whereFun is returned frommkjump (INDICES…) .

template<typename MkFun, size_t ... INDICES>
static auto Ase::make_indexed_table (
    const MkFun & mkjump,
    std::index_sequence< INDICES... >
) 

---

function make_nick3

static String3 Ase::make_nick3 (
    const String & label
) 

---

function match_identifier_detailed

static bool Ase::match_identifier_detailed (
    const String & ident,
    const String & tail
) 

---

function maybe_save_preferences

static void Ase::maybe_save_preferences () 

---

function midi_driver_pref_list_choices

static ChoiceS Ase::midi_driver_pref_list_choices (
    const CString & ident
) 

---

function minmaxstep_from_initialval

static MinMaxStep Ase::minmaxstep_from_initialval (
    const Param::InitialVal & iv,
    bool * isbool
) 

---

function mpc_add

static void Ase::mpc_add (
    uint64_t *const a,
    const uint64_t *const b,
    const uint64_t *const m
) 

---

function mpc_bsub

static void Ase::mpc_bsub (
    uint64_t *const a,
    const uint64_t *const b
) 

---

function mpc_cmp

static int Ase::mpc_cmp (
    const uint64_t *const a,
    const uint64_t *const b
) 

---

function mpc_mul

static void Ase::mpc_mul (
    uint64_t *const a,
    const uint64_t *const b,
    const uint64_t *const m
) 

---

function mpc_rem

static void Ase::mpc_rem (
    uint64_t *const a,
    const uint64_t *const m
) 

---

function musical_tuning_info

static EnumInfo Ase::musical_tuning_info (
    MusicalTuning musicaltuning
) 

---

function notify_loft_lowmem

static void Ase::notify_loft_lowmem () 

---

function notify_preference_listeners

static void Ase::notify_preference_listeners () 

---

function operator!=

static inline bool Ase::operator!= (
    const WppHdl & a,
    const WppHdl & b
) 

---

function operator==

static inline bool Ase::operator== (
    const WppHdl & a,
    const WppHdl & b
) 

---

function parse_args

static void Ase::parse_args (
    int * argcp,
    char ** argv,
    MainAppImpl & config
) 

---

function parse_assignment

static bool Ase::parse_assignment (
    const char ** stringp,
    size_t * linenop,
    String * keyp,
    String * localep,
    String * valuep
) 

---

function parse_section

static bool Ase::parse_section (
    const char ** stringp,
    size_t * linenop,
    String * sectionp
) 

---

function parse_whitespaces

static bool Ase::parse_whitespaces (
    const char ** stringp,
    int min_spaces
) 

---

function pathname_anklangrc

static String Ase::pathname_anklangrc () 

---

function pcg_hash32

template<class Num>
static inline ASE_CONST uint32_t Ase::pcg_hash32 (
    const Num * data,
    size_t length,
    uint64_t seed
) 

Hash function based on the PCG family of random number generators (RNG). This function is based on the paper PCG: A Family of Simple Fast Space-Efficient Statistically Good Algorithms for Random Number Generation, because of its excellent avalange and distribution properties. The hash data is integrated as octets in the inner LCG RNG loop. Hash generation is very fast, because the inner loop consists only of a multiplication and subtraction, while the ouput bit mixing consists of just 5 simple operations (xor, shift and rotation).

---

function pcg_hash64

template<class Num>
static inline ASE_CONST uint64_t Ase::pcg_hash64 (
    const Num * data,
    size_t length,
    uint64_t seed
) 

Hash function based on the PCG family of random number generators (RNG). This function is similar to pcg_hash32() at its core, but because the output is 64bit, the accumulated 64bit LCG state does not need to be bit reduced. A fast but statistially good mixing function with 5 xor/shifts and one multiplication is applied as output stage. This function is allmost as fast as fnv1a_consthash64 due to the similar structures of the inner loops, but it tends to score much better in Avalanche effect tests, usch as SMHasher.

---

function pcg_hash64

pcg_hash64() variant for zero-terminated strings.

static inline ASE_CONST uint64_t Ase::pcg_hash64 (
    const char * ztdata,
    uint64_t seed
) 

---

function pcm_driver_pref_list_choices

static ChoiceS Ase::pcm_driver_pref_list_choices (
    const CString & ident
) 

---

function pcre2compilecontext

static pcre2_compile_context * Ase::pcre2compilecontext () 

---

function pid_string

Create process specific string for a .pid guard file.

static String Ase::pid_string (
    int pid
) 

---

function posix_locale_vprintf

static inline String Ase::posix_locale_vprintf (
    const char * format,
    va_list vargs
) 

---

function preallocate_loft

static void Ase::preallocate_loft (
    size_t preallocation
) 

---

function prefault_pages

static void Ase::prefault_pages (
    size_t stacksize,
    size_t heapsize
) 

---

function prefs_map

static PrefsMap & Ase::prefs_map () 

---

function print_usage

static void Ase::print_usage (
    bool help
) 

---

function queue_notify_preference_listeners

static void Ase::queue_notify_preference_listeners (
    const CString & cident
) 

---

function registered_loaders

static RegisteredLoaderVector & Ase::registered_loaders () 

---

function release_id

static void Ase::release_id (
    uint id
) 

---

function rotl

Bitwise rotate-left pattern recognized by gcc & clang at -O1 iff sizeof (bits) == {8,16,32,64}.

template<typename UInt>
static inline constexpr UInt Ase::rotl (
    UInt bits,
    uint32_t offset
) 

---

function rotr

Bitwise rotate-right pattern recognized by gcc & clang at -O1 iff sizeof (bits) == {8,16,32,64}.

template<typename UInt>
static inline constexpr UInt Ase::rotr (
    UInt bits,
    uint32_t offset
) 

---

function run_tests_and_quit

static void Ase::run_tests_and_quit () 

---

function runtime_entropy

static void Ase::runtime_entropy (
    KeccakRng & pool
) 

---

function scan_escaped

static inline bool Ase::scan_escaped (
    const char ** stringp,
    size_t * linenop,
    const char term
) 

---

function scan_value

static bool Ase::scan_value (
    const char ** stringp,
    size_t * linenop,
    String * valuep,
    const char * termchars=""
) 

---

function search_first_digit

static ssize_t Ase::search_first_digit (
    const String & s
) 

---

function search_last_digits

static ssize_t Ase::search_last_digits (
    const String & s
) 

---

function separator_strlen

static size_t Ase::separator_strlen (
    const char *const s
) 

---

function setup_evnote

static inline clap_event_note * Ase::setup_evnote (
    ClapEventUnion * evunion,
    uint32_t time,
    uint16_t port_index
) 

---

function setup_expression

static inline clap_event_note_expression * Ase::setup_expression (
    ClapEventUnion * evunion,
    uint32_t time,
    uint16_t port_index
) 

---

function setup_midi1

static inline clap_event_midi * Ase::setup_midi1 (
    ClapEventUnion * evunion,
    uint32_t time,
    uint16_t port_index
) 

---

function skip_commentline

static bool Ase::skip_commentline (
    const char ** stringp,
    size_t * linenop,
    String * commentp=NULL
) 

---

function skip_line

static bool Ase::skip_line (
    const char ** stringp,
    size_t * linenop,
    String * textp
) 

---

function skip_to_eol

static bool Ase::skip_to_eol (
    const char ** stringp,
    size_t * linenop
) 

---

function skip_whitespaces

static bool Ase::skip_whitespaces (
    const char ** stringp
) 

---

function spaced_nums

static String Ase::spaced_nums (
    String s
) 

---

function string_hash64

Fast string hashing with good dispersion for std::string and runtime randomization.

static inline ASE_CONST uint64_t Ase::string_hash64 (
    const std::string & string
) 

---

function string_hash64

pcg_hash64() variant for zero-terminated strings.

static inline ASE_CONST uint64_t Ase::string_hash64 (
    const char * ztdata
) 

---

function string_option_find_value

static std::string_view Ase::string_option_find_value (
    const char * string,
    const char * feature,
    const char * fallback,
    const char * denied,
    const int matching
) 

---

function string_read

static String Ase::string_read (
    const String & filename,
    const int fd,
    size_t guess
) 

---

function string_rtrim

static String Ase::string_rtrim (
    String & str
) 

---

function string_whitesplit

static StringS Ase::string_whitesplit (
    const String & string,
    size_t maxn
) 

---

function system_entropy

static void Ase::system_entropy (
    KeccakRng & pool
) 

---

function telemetry_type

static constexpr const char * Ase::telemetry_type (
    const int8 & field
) 

---

function telemetry_type

static constexpr const char * Ase::telemetry_type (
    const int32 & field
) 

---

function telemetry_type

static constexpr const char * Ase::telemetry_type (
    const float & field
) 

---

function telemetry_type

static constexpr const char * Ase::telemetry_type (
    const double & field
) 

---

function timestamp_init_

static void Ase::timestamp_init_ () 

---

function tmpdir_prefix

Prefix for temporary cache directories, also used for pruning of stale directories.

static String Ase::tmpdir_prefix () 

---

function try_load_x11wrapper

static void Ase::try_load_x11wrapper () 

---

function typeid_name

Provide demangled stringified name for type T .

template<class T>
static inline ASE_PURE const char * Ase::typeid_name () 

---

function typeid_name

Provide demangled stringified name for object obj .

template<class T>
static inline ASE_PURE const char * Ase::typeid_name (
    T & obj
) 

---

function unalias_encoding

static bool Ase::unalias_encoding (
    String & name
) 

---

function unalias_ptr

Force compiler to forget the origin of a possibly aliasing pointer.

template<typename T>
static T * Ase::unalias_ptr (
    T * ptr
) 

---

function update_task_status

static bool Ase::update_task_status (
    TaskStatus & self
) 

---

function utf8character

template<int CODEPOINT>
static inline size_t Ase::utf8character (
    const char * str,
    uint32_t * unicode
) 

Decode valid UTF-8 sequences, invalid sequences are treated as Latin-1 characters. * CODEPOINT=0: The return value indicates the number of bytes forgivingly parsed as a single UTF-8 character. * CODEPOINT=1: The return value indicates the number of bytes forgivingly parsed as a single UTF-8 character and *unicode is assigned. If *unicode is >= 0x80, a Latin-1 character was encountered. * CODEPOINT=2: Invalid characters are encoded as private code points in the range 0xEF80..0xEFFF, see also: https://en.wikipedia.org/wiki/UTF-8#PEP_383 * CODEPOINT=3: Validly encoded code points in the range 0xEF80..0xEFFF are also treated as invalid characters and are encoded into 0xEF80..0xEFFF.

---

function utf8codepoint

Returns length of unicode character in bytes.

static inline size_t Ase::utf8codepoint (
    const char * str,
    uint32_t * unicode
) 

---

function utf8skip

Returns length of unicode character in bytes.

static inline size_t Ase::utf8skip (
    const char * str
) 

---

function validate_telemetry_segments

static bool Ase::validate_telemetry_segments (
    const TelemetrySegmentS & segments,
    size_t * payloadlength
) 

---

function value_array_to_string

static String Ase::value_array_to_string (
    const ValueS & vec
) 

---

function value_from_initialval

static Value Ase::value_from_initialval (
    const Param::InitialVal & iv
) 

---

function value_record_to_string

static String Ase::value_record_to_string (
    const ValueR & vec
) 

---

function wav_header

static std::vector< unsigned char > Ase::wav_header (
    const uint8_t n_bits,
    const uint32_t n_channels,
    const uint32_t sample_freq,
    const uint32_t n_samples
) 

---

function wav_write

static int Ase::wav_write (
    int fd,
    uint8_t n_bits,
    uint32_t n_channels,
    uint32_t sample_freq,
    const float * samples,
    size_t n_frames
) 

---

function write_uint

static std::array< char, 12 > Ase::write_uint (
    uint32_t i
) 

---

---

The documentation for this class was generated from the following file /__w/anklang/anklang/ase/api.hh