Lua Bindings Class Reference

This documentation is far from complete may be inaccurate and subject to change.

Pointer Classes

Libardour makes extensive use of reference counted std::shared_ptr to manage lifetimes. The Lua bindings provide a complete abstraction of this. There are no pointers in Lua. For example a ARDOUR:Route is a pointer in C++, but Lua functions operate on it like it was a class instance.

shared_ptr are reference counted. Once assigned to a Lua variable, the C++ object will be kept and remains valid. It is good practice to assign references to Lua local variables or reset the variable to nil to drop the ref.

All pointer classes have a isnil () method. This is for two cases: Construction may fail. e.g. ARDOUR.LuaAPI.newplugin() may not be able to find the given plugin and hence cannot create an object.

The second case if for std::weak_ptr. As opposed to std::shared_ptr weak-pointers are not reference counted. The object may vanish at any time. If Lua code calls a method on a nil object, the interpreter will raise an exception and the script will not continue. This is not unlike a = nil a:test() which results in en error “attempt to index a nil value”.

From the Lua side of things there is no distinction between weak and shared pointers. They behave identically. Below they’re indicated in orange and have an arrow to indicate the pointer type. Pointer Classes cannot be created in Lua scripts. It always requires a call to C++ to create the Object and obtain a reference to it.

Class Documentation

ℕ ARDOUR

Methods
[RCConfiguration](#AR DOUR:RCConfiguration)	[co nfig]{.functionname}[ ()]{.functionargs}
[int]{.em}	[inflate_demo_ses sion]{.functionname}[ ([std::string]{.em}, [std::string]{ .em})]{.functionargs}
[std::string]{.em}	[user_cache_direc tory]{.functionname}[ ([int]{ .em})]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} the path to the directory used to store user specific caches (e.g. plugin indices, blacklist/whitelist) it defaults to XDG_CACHE_HOME ::: ::
[std::string]{.em}	[user_config_direc tory]{.functionname}[ ([int]{ .em})]{.functionargs}
	::: dox us er_config_directory() exists IF version was negative. ::: result-discussion [Re turns]{.word-returns} the path to the directory used to store user specific configuration files for the given version of the program. If version is negative, the build-time string PROGRAM_VERSION will be used to determine the version number. ::: ::

↠ ARDOUR:Amp

C‡: std::shared_ptr< ARDOUR::Amp >, std::weak_ptr< ARDOUR::Amp >

is-a: ARDOUR:Processor

Methods
float	apply_gain (AudioBuffer&, long, long, float, float, long)
GainControl	gain_control ()
bool	isnil ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:AnyTime

C‡: ARDOUR::AnyTime

Constructor
ℂ	ARDOUR.AnyTime (std::string)
Methods
bool	not_zero ()
std::string	str ()

↠ ARDOUR:AsyncMIDIPort

C‡: std::shared_ptr< ARDOUR::AsyncMIDIPort >, std::weak_ptr< ARDOUR::AsyncMIDIPort >

is-a: ARDOUR:MidiPort

Methods
bool	isnil ()
int	write (unsigned char*, unsigned long, unsigned int)

Inherited from ARDOUR:MidiPort

Methods
MidiBuffer	get_midi_buffer (unsigned int)
bool	input_active ()
void	set_input_active (bool)
Cast
AsyncMIDIPort	to_asyncmidiport ()

Inherited from ARDOUR:Port

Methods
[int]{.em}	[con nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[conne cted]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this port is connected to anything ::: ::
[bool]{.em}	[connecte d_to]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox o : Port name ::: result-discussion [Re turns]{.word-returns} true if this port is connected to o, otherwise false. ::: ::
[int]{.em}	[discon nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[disconnect _all]{.functionname}[ ()]{.functionargs}
[PortFlag s](#ARDOUR.PortFlags)	[f lags]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} flags ::: ::
*LuaTable*(...)	[ge t_connected_latency_r ange]{.functionname}[ ([LatencyRange&](# ARDOUR:LatencyRange), [bool]{ .em})]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port short name ::: ::
[bool]{.em}	[physically_conne cted]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[pretty_ name]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port human readable name ::: ::
[LatencyRange]( #ARDOUR:LatencyRange)	[private_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[LatencyRange]( #ARDOUR:LatencyRange)	[public_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[receives_i nput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port receives input, otherwise false ::: ::
[bool]{.em}	[sends_ou tput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port sends output, otherwise false ::: ::
Cast
[AsyncMIDIPort](# ARDOUR:AsyncMIDIPort)	[to_asyncmidi port]{.functionname}[ ()]{.functionargs}
[AudioPor t](#ARDOUR:AudioPort)	[to_audio port]{.functionname}[ ()]{.functionargs}
[MidiPo rt](#ARDOUR:MidiPort)	[to_midi port]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:AudioBackend

C‡: std::shared_ptr< ARDOUR::AudioBackend >, std::weak_ptr< ARDOUR::AudioBackend >

AudioBackend is an high-level abstraction for interacting with the operating system’s audio and midi I/O.

Methods
[unsigned int]{.em}	[buffer_ size]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[device_ name]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[driver_ name]{.functionname}[ ()]{.functionargs}
	::: dox override this if this implementation returns true from requir es_driver_selection() ::
[float]{.em}	[dsp_ load]{.functionname}[ ()]{.functionargs}
	::: dox return the fraction of the time represented by the current buffer size that is being used for each buffer process cycle, as a value from 0.0 to 1.0 E.g. if the buffer size represents 5msec and current processing takes 1msec, the returned value should be 0.2. Implementations can feel free to smooth the values returned over time (e.g. high pass filtering, or its equivalent). ::
[Devic eStatusVector](#ARDOU R:DeviceStatusVector)	[enumerate_dev ices]{.functionname}[ ()]{.functionargs}
	::: dox Returns a collection of DeviceStatuses identifying devices discovered by this backend since the start of the process. Any of the names in each DeviceStatus may be used to identify a device in other calls to the backend, though any of them may become invalid at any time. ::
[StringVec tor](#C:StringVector)	[enumerate_dri vers]{.functionname}[ ()]{.functionargs}
	::: dox If the return value of requir es_driver_selection() is true, then this function can return the list of known driver names. If the return value of requir es_driver_selection() is false, then this function should not be called. If it is called its return value is an empty vector of strings. ::
[Devic eStatusVector](#ARDOU R:DeviceStatusVector)	[enumerate_input_dev ices]{.functionname}[ ()]{.functionargs}
	::: dox Returns a collection of DeviceStatuses identifying input devices discovered by this backend since the start of the process. Any of the names in each DeviceStatus may be used to identify a device in other calls to the backend, though any of them may become invalid at any time. ::
[Devic eStatusVector](#ARDOU R:DeviceStatusVector)	[enumerate_output_dev ices]{.functionname}[ ()]{.functionargs}
	::: dox Returns a collection of DeviceStatuses identifying output devices discovered by this backend since the start of the process. Any of the names in each DeviceStatus may be used to identify a device in other calls to the backend, though any of them may become invalid at any time. ::
[A udioBackendInfo](#ARD OUR:AudioBackendInfo)	[ info]{.functionname}[ ()]{.functionargs}
	::: dox Return the AudioBackendInfo object from which this backend was constructed. ::
[std::string]{.em}	[input_device_ name]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[output_device_ name]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[period_ size]{.functionname}[ ()]{.functionargs}
[float]{.em}	[sample_ rate]{.functionname}[ ()]{.functionargs}
[int]{.em}	[set_buffer_ size]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox Set the buffer size to be used. The device is assumed to use a double buffering scheme, so that one buffer's worth of data can be processed by hardware while software works on the other buffer. All known suitable audio APIs support this model (though ALSA allows for alternate numbers of buffers, and CoreAudio doesn't directly expose the concept). ::
[int]{.em}	[set_device_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Set the name of the device to be used ::
[int]{.em}	[set_dr iver]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Returns zero if the backend can successfully use drivername as the driver, non-zero otherwise. Should not be used unless the backend returns true from requir es_driver_selection() ::
[int]{.em}	[set_input_device_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Set the name of the input device to be used if using separate input/output devices. use_separate_input _and_output_devices() ::
[int]{.em}	[set_output_device_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Set the name of the output device to be used if using separate input/output devices. use_separate_input _and_output_devices() ::
[int]{.em}	[set_peridod_ size]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox Set the period size to be used. must be called before starting the backend. ::
[int]{.em}	[set_sample_ rate]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox Set the sample rate to be used ::
[bool]{.em}	[use_separate _input_and_output_dev ices]{.functionname}[ ()]{.functionargs}
	::: dox An optional alternate interface for backends to provide a facility to select separate input and output devices. If a backend returns true then enum erate_input_devices() and enume rate_output_devices() will be used instead of enumerate_devices() to enumerate devices. Similarly set_input /output_device_name() should be used to set devices instead of set_device_name(). ::

∁ ARDOUR:AudioBackendInfo

C‡: ARDOUR::AudioBackendInfo

Data Members
char*	name

∁ ARDOUR:AudioBuffer

C‡: ARDOUR::AudioBuffer

Buffer containing audio data.

Methods
[void]{.em}	[apply_ gain]{.functionname}[ ([float]{.em}, [long]{ .em})]{.functionargs}
	::: dox Apply a fixed gain factor to the audio buffer gain : gain factor len : number of samples to amplify ::
[bool]{.em}	[check_sil ence]{.functionname}[ ([unsigned int]{.em}, [unsigned int&]{ .em})]{.functionargs}
	::: dox Check buffer for silence nframes : number of samples to check n : first non zero sample (if any) ::: result-discussion [Re turns]{.word-returns} true if all samples are zero ::: ::
[Float Array](#C:FloatArray)	[ data]{.functionname}[ ([long]{ .em})]{.functionargs}
[void]{.em}	[read_ from]{.functionname}[ ([FloatA rray](#C:FloatArray), [long]{.em}, [long]{.em}, [long]{ .em})]{.functionargs}
[void]{.em}	[sil ence]{.functionname}[ ([long]{.em}, [long]{ .em})]{.functionargs}
	::: dox silence buffer len : number of samples to clear offset : start offset ::

∁ ARDOUR:AudioEngine

C‡: ARDOUR::AudioEngine

is-a: ARDOUR:PortManager

Methods
BackendVector	available_backends ()
std::string	current_backend_name ()
bool	freewheeling ()
float	get_dsp_load ()
std::string	get_last_backend_error ()
long	processed_samples ()
bool	running ()
AudioBackend	set_backend (std::string, std::string, std::string)
int	set_buffer_size (unsigned int)
int	set_device_name (std::string)
int	set_sample_rate (float)
bool	setup_required ()
int	start (bool)
int	stop (bool)

Inherited from ARDOUR:PortManager

Methods
[int]{.em}	[con nect]{.functionname}[ ([std::string]{.em}, [std::string]{ .em})]{.functionargs}
[bool]{.em}	[conne cted]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[discon nect]{.functionname}[ ([std::string]{.em}, [std::string]{ .em})]{.functionargs}
[int]{.em}	[disconnect_ port]{.functionname}[ ([Port](#ARDOUR:P ort))]{.functionargs}
LuaTable*([int]{.em}, ...)	[get_backend_p orts]{.functionname}[ ([std::string]{.em}, [DataTyp e](#ARDOUR:DataType), [PortFlags ](#ARDOUR.PortFlags), [String Vector&](#C:StringVec tor))]{.functionargs}
LuaTable*([int]{.em}, ...)	[get_connect ions]{.functionname}[ ([std::string]{.em}, [StringVecto r&](#C:StringVector), [bool]{ .em})]{.functionargs}
[void]{.em}	[get_physical_in puts]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [StringVecto r&](#C:StringVector), [MidiPortFlags](#A RDOUR.MidiPortFlags), [MidiPortFlag s](#ARDOUR.MidiPortFl ags))]{.functionargs}
[void]{.em}	[get_physical_out puts]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [StringVecto r&](#C:StringVector), [MidiPortFlags](#A RDOUR.MidiPortFlags), [MidiPortFlag s](#ARDOUR.MidiPortFl ags))]{.functionargs}
[Port](#ARDOUR:Port)	[get_port_by_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox name : Full or short name of port ::: result-discussion [Re turns]{.word-returns} Corresponding Port or 0. ::: ::
LuaTable*([int]{.em}, ...)	[get_p orts]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [Por tList&](#ARDOUR:PortL ist))]{.functionargs}
[std::string]{.em}	[get_pretty_name_by_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_physical_in puts]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_physical_out puts]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[physically_conne cted]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[PortEngine ](#ARDOUR:PortEngine)	[port_en gine]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[port_is_phys ical]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[void]{.em}	[reset_input_me ters]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:AudioPlaylist

C‡: std::shared_ptr< ARDOUR::AudioPlaylist >, std::weak_ptr< ARDOUR::AudioPlaylist >

is-a: ARDOUR:Playlist

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
timecnt_t	read (FloatArray, FloatArray, FloatArray, timepos_t, timecnt_t, unsigned int)

Inherited from ARDOUR:Playlist

Methods
void	add_region (Region, timepos_t, float, bool)
Region	combine (RegionList, Track)
unsigned int	count_regions_at (timepos_t)
Playlist	cut (TimelineRangeList&)
DataType	data_type ()
void	duplicate (Region, timepos_t&, timecnt_t, float)
void	duplicate_range (TimelineRange&, float)
void	duplicate_until (Region, timepos_t&, timecnt_t, timepos_t)
bool	empty ()
Region	find_next_region (timepos_t, RegionPoint, int)
timepos_t	find_next_region_boundary (timepos_t, int)
long	find_next_transient (timepos_t, int)
ID	get_orig_track_id ()
bool	hidden ()
void	lower_region (Region)
void	lower_region_to_bottom (Region)
unsigned int	n_regions ()
void	raise_region (Region)
void	raise_region_to_top (Region)
Region	region_by_id (ID)
RegionListPtr	region_list ()
RegionListPtr	regions_at (timepos_t)
RegionListPtr	regions_touched (timepos_t, timepos_t)
RegionListPtr	regions_with_end_within (Range)
RegionListPtr	regions_with_start_within (Range)
void	remove_region (Region)
bool	set_name (std::string)
bool	shared ()
void	split_region (Region, timepos_t)
Region	top_region_at (timepos_t)
Region	top_unmuted_region_at (timepos_t)
void	uncombine (Region)
bool	used ()
Cast
AudioPlaylist	to_audioplaylist ()
MidiPlaylist	to_midiplaylist ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:AudioPort

C‡: std::shared_ptr< ARDOUR::AudioPort >, std::weak_ptr< ARDOUR::AudioPort >

is-a: ARDOUR:Port

Methods
bool	isnil ()

Inherited from ARDOUR:Port

Methods
[int]{.em}	[con nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[conne cted]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this port is connected to anything ::: ::
[bool]{.em}	[connecte d_to]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox o : Port name ::: result-discussion [Re turns]{.word-returns} true if this port is connected to o, otherwise false. ::: ::
[int]{.em}	[discon nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[disconnect _all]{.functionname}[ ()]{.functionargs}
[PortFlag s](#ARDOUR.PortFlags)	[f lags]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} flags ::: ::
*LuaTable*(...)	[ge t_connected_latency_r ange]{.functionname}[ ([LatencyRange&](# ARDOUR:LatencyRange), [bool]{ .em})]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port short name ::: ::
[bool]{.em}	[physically_conne cted]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[pretty_ name]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port human readable name ::: ::
[LatencyRange]( #ARDOUR:LatencyRange)	[private_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[LatencyRange]( #ARDOUR:LatencyRange)	[public_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[receives_i nput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port receives input, otherwise false ::: ::
[bool]{.em}	[sends_ou tput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port sends output, otherwise false ::: ::
Cast
[AsyncMIDIPort](# ARDOUR:AsyncMIDIPort)	[to_asyncmidi port]{.functionname}[ ()]{.functionargs}
[AudioPor t](#ARDOUR:AudioPort)	[to_audio port]{.functionname}[ ()]{.functionargs}
[MidiPo rt](#ARDOUR:MidiPort)	[to_midi port]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:AudioPortMeters

C‡: std::map<std::string, ARDOUR::PortManager::DPM >

Constructor
ℂ	ARDOUR.AudioPortMeters ()
Methods
LuaTable	add (std::string, ARDOUR::PortManager::DPM )
.…	at (–lua–)
void	clear ()
unsigned long	count (std::string)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

↠ ARDOUR:AudioRegion

C‡: std::shared_ptr< ARDOUR::AudioRegion >, std::weak_ptr< ARDOUR::AudioRegion >

is-a: ARDOUR:Region

Base class for objects with saveable and undoable state

Methods
[AudioSource] (#ARDOUR:AudioSource)	[audio_so urce]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[AutomationList](#A RDOUR:AutomationList)	[enve lope]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[envelope_ac tive]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[fade_befor e_fx]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[fade_in_ac tive]{.functionname}[ ()]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[fade_in_le ngth]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[fade_out_ac tive]{.functionname}[ ()]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[fade_out_le ngth]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[double]{.em}	[maximum_ampli tude]{.functionname}[ ( [Progress](#PBD:Progr ess))]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} the maximum (linear) amplitude of the region, or a -ve number if the Progress object reports that the process was cancelled. ::: ::
[unsigned int]{.em}	[n_chan nels]{.functionname}[ ()]{.functionargs}
[double]{.em}	[rms]{.functionname}[ ( [Progress](#PBD:Progr ess))]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} the maximum (rms) signal power of the region, or a -1 if the Progress object reports that the process was cancelled. ::: ::
[float]{.em}	[scale_ampli tude]{.functionname}[ ()]{.functionargs}
LuaTable*([int]{.em}, ...)	[separate_by_cha nnel]{.functionname}[ ([RegionVecto r&](#ARDOUR:RegionVec tor))]{.functionargs}
[void]{.em}	[set_envelope_ac tive]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_fade_befor e_fx]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_fade_in_ac tive]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_fade_in_le ngth]{.functionname}[ ([long]{ .em})]{.functionargs}
[void]{.em}	[set_fade_in_s hape]{.functionname}[ ([Fade Shape](#ARDOUR.FadeSh ape))]{.functionargs}
[void]{.em}	[set_fade_out_ac tive]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_fade_out_le ngth]{.functionname}[ ([long]{ .em})]{.functionargs}
[void]{.em}	[set_fade_out_s hape]{.functionname}[ ([Fade Shape](#ARDOUR.FadeSh ape))]{.functionargs}
[void]{.em}	[set_scale_ampli tude]{.functionname}[ ([float]{ .em})]{.functionargs}
Cast
[Readab le](#ARDOUR:Readable)	[to_read able]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Region

Methods
[bool]{.em}	[add_pl ugin]{.functionname}[ ([RegionFxPlugin](#AR DOUR:RegionFxPlugin), [RegionFxPlugin ](#ARDOUR:RegionFxPlu gin))]{.functionargs}
[bool]{.em}	[at_natural_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[autom atic]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[can_ move]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[capt ured]{.functionname}[ ()]{.functionargs}
[void]{.em}	[captured_x runs]{.functionname}[ ([XrunPositions&](#A RDOUR:XrunPositions), [bool]{ .em})]{.functionargs}
[void]{.em}	[clear_sync_posi tion]{.functionname}[ ()]{.functionargs}
[Cont rol](#Evoral:Control)	[con trol]{.functionname}[ ([Parameter ](#Evoral:Parameter), [bool]{ .em})]{.functionargs}
[bool]{.em}	[co vers]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[cut _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[cut_f ront]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[DataTy pe](#ARDOUR:DataType)	[data_ type]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[exte rnal]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[has_transi ents]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[hi dden]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[im port]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_comp ound]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[l ayer]{.functionname}[ ()]{.functionargs}
[timecnt_t] (#Temporal:timecnt_t)	[le ngth]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[load_pl ugin]{.functionname}[ ([PluginType] (#ARDOUR:PluginType), [std::string]{ .em})]{.functionargs}
[bool]{.em}	[lo cked]{.functionname}[ ()]{.functionargs}
[void]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[void]{.em}	[lower_to_bo ttom]{.functionname}[ ()]{.functionargs}
[StringVec tor](#C:StringVector)	[master_source_n ames]{.functionname}[ ()]{.functionargs}
[SourceList ](#ARDOUR:SourceList)	[master_sou rces]{.functionname}[ ()]{.functionargs}
[void]{.em}	[move_s tart]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[void]{.em}	[move_to_natural_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[m uted]{.functionname}[ ()]{.functionargs}
[RegionFxPlugin](#A RDOUR:RegionFxPlugin)	[nth_pl ugin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[void]{.em}	[nudge_posi tion]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[bool]{.em}	[op aque]{.functionname}[ ()]{.functionargs}
[Playli st](#ARDOUR:Playlist)	[play list]{.functionname}[ ()]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[posi tion]{.functionname}[ ()]{.functionargs}
	::: dox How the region parameters play together: POSITION: first sample of the region along the timeline START: first sample of the region within its source(s) LENGTH: number of samples the region represents ::
[bool]{.em}	[position_lo cked]{.functionname}[ ()]{.functionargs}
[void]{.em}	[r aise]{.functionname}[ ()]{.functionargs}
[void]{.em}	[raise_to _top]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[remove_pl ugin]{.functionname}[ ([RegionFxPlugin](#AR DOUR:RegionFxPlugin), [RegionFxPlugin ](#ARDOUR:RegionFxPlu gin))]{.functionargs}
[void]{.em}	[set_hi dden]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_initial_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_le ngth]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[void]{.em}	[set_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_m uted]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Note: changing the name of a Region does not constitute an edit ::
[void]{.em}	[set_op aque]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_position_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_s tart]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_sync_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_video_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[float]{.em}	[s hift]{.functionname}[ ()]{.functionargs}
[So urce](#ARDOUR:Source)	[so urce]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[s tart]{.functionname}[ ()]{.functionargs}
[float]{.em}	[str etch]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[sync_ma rked]{.functionname}[ ()]{.functionargs}
*L uaTable*([timecnt_t]( #Temporal:timecnt_t), ...)	[sync_of fset]{.functionname}[ ([int&]{ .em})]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[sync_posi tion]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Sync position in session time ::: ::
[Int 64List](#C:Int64List)	[transi ents]{.functionname}[ ()]{.functionargs}
[void]{.em}	[trim _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[trim_f ront]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[tri m_to]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[bool]{.em}	[video_lo cked]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[whole_ file]{.functionname}[ ()]{.functionargs}
Cast
[AudioRegion] (#ARDOUR:AudioRegion)	[to_audiore gion]{.functionname}[ ()]{.functionargs}
[MidiRegion ](#ARDOUR:MidiRegion)	[to_midire gion]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:AudioRom

C‡: std::shared_ptr< ARDOUR::AudioRom >, std::weak_ptr< ARDOUR::AudioRom >

is-a: ARDOUR:Readable

Methods
bool	isnil ()
AudioRom	new_rom (FloatArray, unsigned long)

Inherited from ARDOUR:Readable

Methods
ReadableList	load (Session&, std::string)
unsigned int	n_channels ()
long	read (FloatArray, long, long, int)
long	readable_length ()

↠ ARDOUR:AudioSource

C‡: std::shared_ptr< ARDOUR::AudioSource >, std::weak_ptr< ARDOUR::AudioSource >

is-a: ARDOUR:Source

Base class for objects with saveable and undoable state

Methods
std::string	captured_for ()
bool	empty ()
bool	isnil ()
bool	isnil ()
timepos_t	length ()
unsigned int	n_channels ()
unsigned int	n_channels ()
long	read (FloatArray, long, long, int)
long	readable_length ()
long	readable_length ()
float	sample_rate ()
Cast
Readable	to_readable ()

Inherited from ARDOUR:Source

Methods
std::string	ancestor_name ()
bool	can_be_analysed ()
XrunPositions	captured_xruns ()
bool	has_been_analysed ()
timepos_t	natural_position ()
timepos_t	timeline_position ()
long	timestamp ()
int	use_count ()
bool	used ()
bool	writable ()
Cast
AudioSource	to_audiosource ()
FileSource	to_filesource ()
MidiSource	to_midisource ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:AudioTrack

C‡: std::shared_ptr< ARDOUR::AudioTrack >, std::weak_ptr< ARDOUR::AudioTrack >

is-a: ARDOUR:Track

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:Track

Constructor
ℵ	[ARDOUR.T rack]{.functionname}[ ()]{.functionargs}
Methods
[Re gion](#ARDOUR:Region)	[bo unce]{.functionname}[ ([I nterThreadInfo&](#ARD OUR:InterThreadInfo), [std::string]{ .em})]{.functionargs}
[Re gion](#ARDOUR:Region)	[bounce_r ange]{.functionname}[ ([long]{.em}, [long]{.em}, [I nterThreadInfo&](#ARD OUR:InterThreadInfo), [Processor ](#ARDOUR:Processor), [bool]{.em}, [std::string]{.em}, [bool]{ .em})]{.functionargs}
[bool]{.em}	[bounce able]{.functionname}[ ([Processor ](#ARDOUR:Processor), [bool]{ .em})]{.functionargs}
	::: dox Test if the track can be bounced with the given settings. If sends/inserts/returns are present in the signal path or the given track has no audio outputs bouncing is not possible. endpoint : the processor to tap the signal off (or nil for the top) include_endpoint : include the given processor in the bounced audio. ::: result-discussion [Re turns]{.word-returns} true if the track can be bounced, or false otherwise. ::: ::
[bool]{.em}	[can_re cord]{.functionname}[ ()]{.functionargs}
[int]{.em}	[find_and_use_play list]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [ID](#PBD :ID))]{.functionargs}
[Playli st](#ARDOUR:Playlist)	[play list]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[use_copy_play list]{.functionname}[ ()]{.functionargs}
[int]{.em}	[use_new_play list]{.functionname}[ ([Da taType](#ARDOUR:DataT ype))]{.functionargs}
[int]{.em}	[use_play list]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [Playlis t](#ARDOUR:Playlist), [bool]{ .em})]{.functionargs}
Cast
[AudioTrack ](#ARDOUR:AudioTrack)	[to_audio_t rack]{.functionname}[ ()]{.functionargs}
[MidiTrac k](#ARDOUR:MidiTrack)	[to_midi_t rack]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Route

Methods
[bool]{.em}	[ac tive]{.functionname}[ ()]{.functionargs}
[int]{.em}	[add_aux_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox Add an aux send to a route. route : route to send to. before : Processor to insert before, or 0 to insert at the end. ::
[int]{.em}	[add_foldback_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [bool]{ .em})]{.functionargs}
[int]{.em}	[add_processor_by_i ndex]{.functionname}[ ([Processor ](#ARDOUR:Processor), [int]{.em}, [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[bool]{.em}	[add_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[Amp](#ARDOUR:Amp)	[amp]{.functionname}[ ()]{.functionargs}
[void]{.em}	[clear_stripa bles]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[com ment]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[customize_plugin_in sert]{.functionname}[ ([Processor ](#ARDOUR:Processor), [unsigned int]{.em}, [ChanCount ](#ARDOUR:ChanCount), [Chan Count](#ARDOUR:ChanCo unt))]{.functionargs}
[DataTy pe](#ARDOUR:DataType)	[data_ type]{.functionname}[ ()]{.functionargs}
[Stripabl e](#ARDOUR:Stripable)	[first_selected_strip able]{.functionname}[ ()]{.functionargs}
[IO](#ARDOUR:IO)	[i nput]{.functionname}[ ()]{.functionargs}
[Delive ry](#ARDOUR:Delivery)	[main_ outs]{.functionname}[ ()]{.functionargs}
[MonitorControl](#A RDOUR:MonitorControl)	[monitoring_con trol]{.functionname}[ ()]{.functionargs}
[MonitorState]( #ARDOUR.MonitorState)	[monitoring_s tate]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[m uted]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_in puts]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_out puts]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_pl ugin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_proce ssor]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_ send]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[IO](#ARDOUR:IO)	[ou tput]{.functionname}[ ()]{.functionargs}
[PannerShell] (#ARDOUR:PannerShell)	[panner_s hell]{.functionname}[ ()]{.functionargs}
[PeakMete r](#ARDOUR:PeakMeter)	[peak_m eter]{.functionname}[ ()]{.functionargs}
[long]{.em}	[playback_lat ency]{.functionname}[ ([bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[remove_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[int]{.em}	[reorder_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[int]{.em}	[replace_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processor ](#ARDOUR:Processor), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[reset_plugin_in sert]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox reset plugin-insert configuration to default, disable customizations. This is equivalent to calling customize_plugin_ins ert (proc, 0, unused) proc : Processor to reset ::: result-discussion [Re turns]{.word-returns} true if successful ::: ::
[int]{.em}	[save_as_temp late]{.functionname}[ ([std::string]{.em}, [std::string]{.em}, [std::string]{ .em})]{.functionargs}
[void]{.em}	[select_next_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[select_prev_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[set_ac tive]{.functionname}[ ([bool]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_com ment]{.functionname}[ ([std::string]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_meter_p oint]{.functionname}[ ([MeterP oint](#ARDOUR.MeterPo int))]{.functionargs}
[bool]{.em}	[set_stric t_io]{.functionname}[ ([bool]{ .em})]{.functionargs}
[long]{.em}	[signal_lat ency]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[so loed]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[stric t_io]{.functionname}[ ()]{.functionargs}
[SurroundReturn](#A RDOUR:SurroundReturn)	[surround_re turn]{.functionname}[ ()]{.functionargs}
[SurroundSend]( #ARDOUR:SurroundSend)	[surround_ send]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[the_instru ment]{.functionname}[ ()]{.functionargs}
	::: dox Return the first processor that accepts has at least one MIDI input and at least one audio output. In the vast majority of cases, this will be "the instrument". This does not preclude other MIDI->audio processors later in the processing chain, but that would be a special case not covered by this utility function. ::
[Amp](#ARDOUR:Amp)	[ trim]{.functionname}[ ()]{.functionargs}
Cast
[ Track](#ARDOUR:Track)	[to_t rack]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Stripable

Methods
unsigned int	eq_band_cnt ()
std::string	eq_band_name (unsigned int)
GainControl	gain_control ()
bool	is_auditioner ()
bool	is_hidden ()
bool	is_master ()
bool	is_monitor ()
bool	is_private_route ()
bool	is_selected ()
bool	is_surround_master ()
AutomationControl	mapped_control (WellKnownCtrl, unsigned int)
ReadOnlyControl	mapped_output (WellKnownData)
AutomationControl	master_send_enable_controllable ()
MonitorProcessor	monitor_control ()
MuteControl	mute_control ()
AutomationControl	pan_azimuth_control ()
AutomationControl	pan_elevation_control ()
AutomationControl	pan_frontback_control ()
AutomationControl	pan_lfe_control ()
AutomationControl	pan_width_control ()
PhaseControl	phase_control ()
PresentationInfo	presentation_info_ptr ()
AutomationControl	rec_enable_control ()
AutomationControl	rec_safe_control ()
AutomationControl	send_enable_controllable (unsigned int)
AutomationControl	send_level_controllable (unsigned int, bool)
std::string	send_name (unsigned int)
AutomationControl	send_pan_azimuth_controllable (unsigned int)
AutomationControl	send_pan_azimuth_enable_controllable (unsigned int)
void	set_presentation_order (unsigned int)
bool	slaved ()
bool	slaved_to (VCA)
SoloControl	solo_control ()
SoloIsolateControl	solo_isolate_control ()
SoloSafeControl	solo_safe_control ()
GainControl	trim_control ()
Cast
Automatable	to_automatable ()
Route	to_route ()
Slavable	to_slavable ()
VCA	to_vca ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:AudioTrackList

C‡: std::list<std::shared_ptr<ARDOUR::AudioTrack> >

Constructor
ℂ	ARDOUR.AudioTrackList ()
Methods
LuaTable	add (LuaTable {AudioTrack})
AudioTrack	back ()
void	clear ()
bool	empty ()
AudioTrack	front ()
LuaIter	iter ()
void	push_back (AudioTrack)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

↠ ARDOUR:Automatable

C‡: std::shared_ptr< ARDOUR::Automatable >, std::weak_ptr< ARDOUR::Automatable >

is-a: Evoral:ControlSet

Methods
[ParameterList](# ARDOUR:ParameterList)	[all_automatable_pa rams]{.functionname}[ ()]{.functionargs}
	::: dox API for Lua binding ::
[Aut omationControl](#ARDO UR:AutomationControl)	[automation_con trol]{.functionname}[ ([Parameter ](#Evoral:Parameter), [bool]{ .em})]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
Cast
[Slavab le](#ARDOUR:Slavable)	[to_slav able]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:AutomatableSequence

C‡: std::shared_ptr< ARDOUR::AutomatableSequence<Temporal::Beats> >, std::weak_ptr< ARDOUR::AutomatableSequence<Temporal::Beats> >

is-a: ARDOUR:Automatable

Methods
bool	isnil ()
Cast
Sequence	to_sequence ()

Inherited from ARDOUR:Automatable

Methods
[ParameterList](# ARDOUR:ParameterList)	[all_automatable_pa rams]{.functionname}[ ()]{.functionargs}
	::: dox API for Lua binding ::
[Aut omationControl](#ARDO UR:AutomationControl)	[automation_con trol]{.functionname}[ ([Parameter ](#Evoral:Parameter), [bool]{ .em})]{.functionargs}
Cast
[Slavab le](#ARDOUR:Slavable)	[to_slav able]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:AutomationControl

C‡: std::shared_ptr< ARDOUR::AutomationControl >, std::weak_ptr< ARDOUR::AutomationControl >

is-a: PBD:Controllable

A PBD::Controllable with associated automation data (AutomationList)

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:AutomationList

C‡: std::shared_ptr< ARDOUR::AutomationList >, std::weak_ptr< ARDOUR::AutomationList >

is-a: Evoral:ControlList

Methods
XMLNode	get_state ()
bool	isnil ()
Command	memento_command (XMLNode, XMLNode)
bool	touch_enabled ()
bool	touching ()
bool	writing ()
Cast
ControlList	list ()
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

Inherited from Evoral:ControlList

Methods
[void]{.em}	[add]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [double]{.em}, [bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[c lear]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[clear_ list]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[editor _add]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [double]{.em}, [bool]{ .em})]{.functionargs}
[double]{.em}	[ eval]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[EventLis t](#ARDOUR:EventList)	[ev ents]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} the list of events ::: ::
[bool]{.em}	[in_write_ pass]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if transport is running and this list is in write mode ::: ::
[InterpolationStyl e](#Evoral.ControlLis t.InterpolationStyle)	[interpola tion]{.functionname}[ ()]{.functionargs}
	::: dox query interpolation style of the automation data ::: result-discussion [Re turns]{.word-returns} Interpolation Style ::: ::
*Lua Table*([double]{.em}, ...)	[rt_safe_ eval]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [bool&]{ .em})]{.functionargs}
[bool]{.em}	[set_interpola tion]{.functionname}[ ([Interpolation Style](#Evoral.Contro lList.InterpolationSt yle))]{.functionargs}
[unsigned long]{.em}	[ size]{.functionname}[ ()]{.functionargs}
[void]{.em}	[ thin]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox Thin the number of events in this list. The thinning factor corresponds to the area of a triangle computed between three points in the list (time-difference * value-difference). If the area is large, it indicates significant non-linearity between the points. Time is measured in samples, value is usually normalized to 0..1. During automation recording we thin the recorded points using this value. If a point is sufficiently co-linear with its neighbours (as defined by the area of the triangle formed by three of them), we will not include it in the list. The larger the value, the more points are excluded, so this effectively measures the amount of thinning to be done. thinning_factor : area-size (default: 20) ::
[void]{.em}	[truncate _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[truncate_s tart]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
Cast
[AutomationList](#A RDOUR:AutomationList)	[to_automation list]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:AutomationTypeSet

C‡: std::set<ARDOUR::AutomationType >

Constructor
ℂ	ARDOUR.AutomationTypeSet ()
Methods
void	clear ()
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:BackendVector

C‡: std::vector<ARDOUR::AudioBackendInfo const* >

Constructor
ℂ	ARDOUR.BackendVector ()
Methods
AudioBackendInfo	at (unsigned long)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:BufferSet

C‡: ARDOUR::BufferSet

A set of buffers of various types.

These are mainly accessed from Session and passed around as scratch buffers (eg as parameters to run() methods) to do in-place signal processing.

There are two types of counts associated with a BufferSet - available, and the ‘use count’. Available is the actual number of allocated buffers (and so is the maximum acceptable value for the use counts).

The use counts are how things determine the form of their input and inform others the form of their output (eg what they did to the BufferSet). Setting the use counts is realtime safe.

Methods
ChanCount	available ()
ChanCount	count ()
AudioBuffer	get_audio (unsigned long)
MidiBuffer	get_midi (unsigned long)

↠ ARDOUR:Bundle

C‡: std::shared_ptr< ARDOUR::Bundle >, std::weak_ptr< ARDOUR::Bundle >

A set of `channels’, each of which is associated with 0 or more ports. Each channel has a name which can be anything useful, and a data type. Intended for grouping things like, for example, a buss’ outputs. `Channel’ is a rather overloaded term but I can’t think of a better one right now.

Methods
[std::string]{.em}	[channel_ name]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox ch : Channel. ::: result-discussion [Re turns]{.word-returns} Channel name. ::: ::
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[n_t otal]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Bundle name ::: ::
[ChanCoun t](#ARDOUR:ChanCount)	[nchan nels]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Number of channels that this Bundle has ::: ::
[bool]{.em}	[ports_are_in puts]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ports_are_out puts]{.functionname}[ ()]{.functionargs}
Cast
[UserBundle ](#ARDOUR:UserBundle)	[to_userbu ndle]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:BundleListPtr

C‡: std::shared_ptr<std::vector<std::shared_ptr<ARDOUR::Bundle> > >

Constructor
ℂ	ARDOUR.BundleListPtr ()
Methods
LuaTable	add (LuaTable {Bundle})
Bundle	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (Bundle)
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:ChanCount

C‡: ARDOUR::ChanCount

A count of channels, possibly with many types.

Operators are defined so this may safely be used as if it were a simple (single-typed) integer count of channels.

Constructor
ℂ	[ARDOUR.ChanC ount]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [unsigned int]{ .em})]{.functionargs}
Methods
[unsigned int]{.em}	[get]{.functionname}[ ([Da taType](#ARDOUR:DataT ype))]{.functionargs}
[unsigned int]{.em}	[n_a udio]{.functionname}[ ()]{.functionargs}
	::: dox query number of audio channels ::: result-discussion [Re turns]{.word-returns} number of audio channels ::: ::
[unsigned int]{.em}	[n_ midi]{.functionname}[ ()]{.functionargs}
	::: dox query number of midi channels ::: result-discussion [Re turns]{.word-returns} number of midi channels ::: ::
[unsigned int]{.em}	[n_t otal]{.functionname}[ ()]{.functionargs}
	::: dox query total channel count of all data types ::: result-discussion [Re turns]{.word-returns} total channel count (audio + midi) ::: ::
[void]{.em}	[r eset]{.functionname}[ ()]{.functionargs}
	::: dox zero count of all data types ::
[void]{.em}	[set]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [unsigned int]{ .em})]{.functionargs}
[void]{.em}	[set_a udio]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox set number of audio channels a : number of audio channels ::
[void]{.em}	[set_ midi]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox set number of audio channels m : number of midi channels ::

∁ ARDOUR:ChanMapping

C‡: ARDOUR::ChanMapping

A mapping from one set of channels to another. The general form is 1 source (from), many sinks (to). numeric IDs are used to identify sources and sinks.

for plugins this is used to map “plugin-pin” to “audio-buffer”

Constructor
ℂ	[ARDOUR.ChanMap ping]{.functionname}[ ()]{.functionargs}
Methods
[ChanCoun t](#ARDOUR:ChanCount)	[c ount]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[is_monot onic]{.functionname}[ ()]{.functionargs}
	::: dox Test if this mapping is monotonic (useful to see if inplace processing is feasible) ::: result-discussion [Re turns]{.word-returns} true if the map is a strict monotonic set ::: ::
[unsigned int]{.em}	[n_t otal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [unsigned int]{.em}, [unsigned int]{ .em})]{.functionargs}

∁ ARDOUR:ConstBundleListPtr

C‡: std::shared_ptr<std::vector<std::shared_ptr<ARDOUR::Bundle> > const>

Constructor
ℂ	ARDOUR.ConstBundleListPtr ()
Methods
Bundle	at (unsigned long)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:ConstRouteListPtr

C‡: std::shared_ptr<std::list<std::shared_ptr<ARDOUR::Route> > const>

Constructor
ℂ	ARDOUR.ConstRouteListPtr ()
Methods
bool	empty ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:ControlList

C‡: std::list<std::shared_ptr<ARDOUR::AutomationControl> >

Constructor
ℂ	ARDOUR.ControlList ()
Methods
LuaTable	add (LuaTable {AutomationControl})
AutomationControl	back ()
void	clear ()
bool	empty ()
AutomationControl	front ()
LuaIter	iter ()
void	push_back (AutomationControl)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ARDOUR:ControlListPtr

C‡: std::shared_ptr<std::list<std::shared_ptr<ARDOUR::AutomationControl> > >

Constructor
ℂ	ARDOUR.ControlListPtr ()
Methods
LuaTable	add (LuaTable {AutomationControl})
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (AutomationControl)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ARDOUR:ControlProtocolInfo

C‡: ARDOUR::ControlProtocolInfo

Methods
bool	active ()
Data Members
std::string	name

∁ ARDOUR:ControlProtocolInfoList

C‡: std::list<ARDOUR::ControlProtocolInfo* >

Constructor
ℂ	ARDOUR.ControlProtocolInfoList ()
Methods
ControlProtocolInfo	back ()
bool	empty ()
ControlProtocolInfo	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:ControlProtocolManager

C‡: ARDOUR::ControlProtocolManager

Methods
int	activate (ControlProtocolInfo&)
ControlProtocolInfoList	control_protocol_infos ()
int	deactivate (ControlProtocolInfo&)
ControlProtocolManager	manager ()

∁ ARDOUR:ControllableSet

C‡: std::set<std::shared_ptr<PBD::Controllable> > >

Constructor
ℂ	ARDOUR.ControllableSet ()
Methods
void	clear ()
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

ℕ ARDOUR.DSP

Methods
[float]{.em}	[a ccurate_coefficient_t o_dB]{.functionname}[ ([float]{ .em})]{.functionargs}
[void]{.em}	[apply_gain_to_bu ffer]{.functionname}[ ([FloatA rray](#C:FloatArray), [unsigned int]{.em}, [float]{ .em})]{.functionargs}
[float]{.em}	[compute_ peak]{.functionname}[ ([FloatA rray](#C:FloatArray), [unsigned int]{.em}, [float]{ .em})]{.functionargs}
[void]{.em}	[copy_ve ctor]{.functionname}[ ([FloatA rray](#C:FloatArray), [FloatA rray](#C:FloatArray), [unsigned int]{ .em})]{.functionargs}
[float]{.em}	[dB_to_coeffic ient]{.functionname}[ ([float]{ .em})]{.functionargs}
[float]{.em}	[fast_coefficient_t o_dB]{.functionname}[ ([float]{ .em})]{.functionargs}
[void]{.em}	[find_p eaks]{.functionname}[ ([FloatA rray](#C:FloatArray), [unsigned int]{.em}, [FloatA rray](#C:FloatArray), [F loatArray](#C:FloatAr ray))]{.functionargs}
[float]{.em}	[log_m eter]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox non-linear power-scale meter deflection power : signal power (dB) ::: result-discussion [Re turns]{.word-returns} deflected value ::: ::
[float]{.em}	[log_meter_c oeff]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox non-linear power-scale meter deflection coeff : signal value ::: result-discussion [Re turns]{.word-returns} deflected value ::: ::
[void]{.em}	[me mset]{.functionname}[ ([FloatA rray](#C:FloatArray), [float]{.em}, [unsigned int]{ .em})]{.functionargs}
	::: dox lua wrapper to memset() ::
[void]{.em}	[mix_buffers_no_ gain]{.functionname}[ ([FloatA rray](#C:FloatArray), [FloatA rray](#C:FloatArray), [unsigned int]{ .em})]{.functionargs}
[void]{.em}	[mix_buffers_with_ gain]{.functionname}[ ([FloatA rray](#C:FloatArray), [FloatA rray](#C:FloatArray), [unsigned int]{.em}, [float]{ .em})]{.functionargs}
[void]{.em}	[m mult]{.functionname}[ ([FloatA rray](#C:FloatArray), [FloatA rray](#C:FloatArray), [unsigned int]{ .em})]{.functionargs}
	::: dox matrix multiply multiply every sample of `data' with the corresponding sample at `mult'. data : multiplicand mult : multiplicand n_samples : number of samples in data and mmult ::
*LuaTable*(...)	[p eaks]{.functionname}[ ([FloatA rray](#C:FloatArray), [float&]{.em}, [float&]{.em}, [unsigned int]{ .em})]{.functionargs}
[void]{.em}	[process _map]{.functionname}[ ([BufferSet ](#ARDOUR:BufferSet), [ChanCount ](#ARDOUR:ChanCount), [ChanMapping]( #ARDOUR:ChanMapping), [ChanMapping]( #ARDOUR:ChanMapping), [unsigned int]{.em}, [long]{ .em})]{.functionargs}

∁ ARDOUR:DSP:Biquad

C‡: ARDOUR::DSP::Biquad

Biquad Filter

Constructor
ℂ	[ARDOUR.DSP.Bi quad]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox Instantiate Biquad Filter samplerate : Samplerate ::
Methods
[void]{.em}	[com pute]{.functionname}[ ([Type](#ARD OUR.DSP.Biquad.Type), [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
[void]{.em}	[confi gure]{.functionname}[ ([Bi quad](#ARDOUR:DSP:Biq uad))]{.functionargs}
[float]{.em}	[dB_at_ freq]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox filter transfer function (filter response for spectrum visualization) freq : frequency ::: result-discussion [Re turns]{.word-returns} gain at given frequency in dB (clamped to -120..+120) ::: ::
[void]{.em}	[r eset]{.functionname}[ ()]{.functionargs}
	::: dox reset filter state ::
[void]{.em}	[run]{.functionname}[ ([FloatA rray](#C:FloatArray), [unsigned int]{ .em})]{.functionargs}
	::: dox process audio data data : pointer to audio-data n_samples : number of samples to process ::
[void]{.em}	[set_coeffici ents]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}

∁ ARDOUR:DSP:Convolution

C‡: ARDOUR::DSP::Convolution

Constructor
ℂ	ARDOUR.DSP.Convolution (Session&, unsigned int, unsigned int)
Methods
bool	add_impdata (unsigned int, unsigned int, Readable, float, unsigned int, long, long, unsigned int)
void	clear_impdata ()
unsigned int	latency ()
unsigned int	n_inputs ()
unsigned int	n_outputs ()
bool	ready ()
void	restart ()
void	run (BufferSet&, ChanMapping, ChanMapping, unsigned int, long)
void	run_mono_buffered (FloatArray, unsigned int)
void	run_mono_no_latency (FloatArray, unsigned int)

∁ ARDOUR:DSP:Convolver

C‡: ARDOUR::DSP::Convolver

is-a: ARDOUR:DSP:Convolution

Constructor
ℂ	ARDOUR.DSP.Convolver (Session&, std::string, IRChannelConfig, IRSettings)
Methods
void	run_stereo_buffered (FloatArray, FloatArray, unsigned int)
void	run_stereo_no_latency (FloatArray, FloatArray, unsigned int)

Inherited from ARDOUR:DSP:Convolution

Constructor
ℂ	ARDOUR.DSP.Convolution (Session&, unsigned int, unsigned int)
Methods
bool	add_impdata (unsigned int, unsigned int, Readable, float, unsigned int, long, long, unsigned int)
void	clear_impdata ()
unsigned int	latency ()
unsigned int	n_inputs ()
unsigned int	n_outputs ()
bool	ready ()
void	restart ()
void	run (BufferSet&, ChanMapping, ChanMapping, unsigned int, long)
void	run_mono_buffered (FloatArray, unsigned int)
void	run_mono_no_latency (FloatArray, unsigned int)

∁ ARDOUR:DSP:DspShm

C‡: ARDOUR::DSP::DspShm

C/C++ Shared Memory

A convenience class representing a C array of float[] or int32_t[] data values. This is useful for lua scripts to perform DSP operations directly using C/C++ with CPU Hardware acceleration.

Access to this memory area is always 4 byte aligned. The data is interpreted either as float or as int.

This memory area can also be shared between different instances or the same lua plugin (DSP, GUI).

Since memory allocation is not realtime safe it should be allocated during dsp_init() or dsp_configure(). The memory is free()ed automatically when the lua instance is destroyed.

Constructor
ℂ	[ARDOUR.DSP.Ds pShm]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
Methods
[void]{.em}	[allo cate]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
	::: dox [re] allocate memory in host's memory space s : size, total number of float or integer elements to store. ::
[int]{.em}	[atomic_get _int]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
	::: dox atomically read integer at offset This involves a memory barrier. This call is intended for buffers which are shared with another instance. off : offset in shared memory region ::: result-discussion [Re turns]{.word-returns} value at offset ::: ::
[void]{.em}	[atomic_set _int]{.functionname}[ ([unsigned long]{.em}, [int]{ .em})]{.functionargs}
	::: dox atomically set integer at offset This involves a memory barrier. This call is intended for buffers which are shared with another instance. off : offset in shared memory region val : value to set ::
[void]{.em}	[c lear]{.functionname}[ ()]{.functionargs}
	::: dox clear memory (set to zero) ::
[Float Array](#C:FloatArray)	[to_f loat]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
	::: dox access memory as float array off : offset in shared memory region ::: result-discussion [Re turns]{.word-returns} float[] ::: ::
[I ntArray](#C:IntArray)	[to _int]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
	::: dox access memory as integer array off : offset in shared memory region ::: result-discussion [Re turns]{.word-returns} int_32_t[] ::: ::

∁ ARDOUR:DSP:FFTSpectrum

C‡: ARDOUR::DSP::FFTSpectrum

Constructor
ℂ	[ARDOUR.DSP.FFTSpec trum]{.functionname}[ ([unsigned int]{.em}, [double]{ .em})]{.functionargs}
Methods
[void]{.em}	[exe cute]{.functionname}[ ()]{.functionargs}
	::: dox process current data in buffer ::
[float]{.em}	[freq_at _bin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[float]{.em}	[power_at _bin]{.functionname}[ ([unsigned int]{.em}, [float]{.em}, [bool]{ .em})]{.functionargs}
	::: dox query bin : the frequency bin 0 .. window_size / 2 norm : gain factor (set equal to bin for 1/f normalization) ::: result-discussion [Re turns]{.word-returns} signal power at given bin (in dBFS) ::: ::
[void]{.em}	[set_data_ hann]{.functionname}[ ([FloatA rray](#C:FloatArray), [unsigned int]{.em}, [unsigned int]{ .em})]{.functionargs}

∁ ARDOUR:DSP:Generator

C‡: ARDOUR::DSP::Generator

Constructor
ℂ	ARDOUR.DSP.Generator ()
Methods
void	run (FloatArray, unsigned int)
void	set_type (Type)

∁ ARDOUR:DSP:IRSettings

C‡: ARDOUR::DSP::Convolver::IRSettings

Constructor
ℂ	ARDOUR.DSP.IRSettings ()
Methods
unsigned int	get_channel_delay (unsigned int)
float	get_channel_gain (unsigned int)
void	set_channel_delay (unsigned int, unsigned int)
void	set_channel_gain (unsigned int, float)
Data Members
float	gain
unsigned int	pre_delay

∁ ARDOUR:DSP:LTCReader

C‡: ARDOUR::LTCReader

Constructor
ℂ	ARDOUR.DSP.LTCReader (int, LTC_TV_STANDARD)
Methods
LuaTable(long, .…)	read (unsigned int&, unsigned int&, unsigned int&, unsigned int&, long&)
void	write (FloatArray, long, long)

∁ ARDOUR:DSP:LowPass

C‡: ARDOUR::DSP::LowPass

1st order Low Pass filter

Constructor
ℂ	[ARDOUR.DSP.Low Pass]{.functionname}[ ([double]{.em}, [float]{ .em})]{.functionargs}
	::: dox instantiate a LPF samplerate : samplerate freq : cut-off frequency ::
Methods
[void]{.em}	[ ctrl]{.functionname}[ ([FloatA rray](#C:FloatArray), [float]{.em}, [unsigned int]{ .em})]{.functionargs}
	::: dox filter control data This is useful for parameter smoothing. data : pointer to control-data array val : target value n_samples : array length ::
[void]{.em}	[ proc]{.functionname}[ ([FloatA rray](#C:FloatArray), [unsigned int]{ .em})]{.functionargs}
	::: dox process audio data data : pointer to audio-data n_samples : number of samples to process ::
[void]{.em}	[r eset]{.functionname}[ ()]{.functionargs}
	::: dox reset filter state ::
[void]{.em}	[set_cu toff]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox update filter cut-off frequency freq : cut-off frequency ::

∁ ARDOUR:DSP:StereoCorrelation

C‡: ARDOUR::DSP::StereoCorrelation

Constructor
ℂ	ARDOUR.DSP.StereoCorrelation (float, float, float)
Methods
void	process (FloatArray, FloatArray, unsigned int)
float	read ()
void	reset ()

∁ ARDOUR:DataType

C‡: ARDOUR::DataType

A type of Data Ardour is capable of processing.

The majority of this class is dedicated to conversion to and from various other type representations, simple comparison between then, etc. This code is deliberately ‘ugly’ so other code doesn’t have to be.

Constructor
ℂ	[ARDOUR.Data Type]{.functionname}[ ([std::string]{ .em})]{.functionargs}
Methods
[DataTy pe](#ARDOUR:DataType)	[a udio]{.functionname}[ ()]{.functionargs}
	::: dox convenience constructor for DataType::AUDIO with managed lifetime ::: result-discussion [Re turns]{.word-returns} DataType::AUDIO ::: ::
[DataTy pe](#ARDOUR:DataType)	[ midi]{.functionname}[ ()]{.functionargs}
	::: dox convenience constructor for DataType::MIDI with managed lifetime ::: result-discussion [Re turns]{.word-returns} DataType::MIDI ::: ::
[DataTy pe](#ARDOUR:DataType)	[ null]{.functionname}[ ()]{.functionargs}
	::: dox convenience constructor for DataType::NIL with managed lifetime ::: result-discussion [Re turns]{.word-returns} DataType::NIL ::: ::
[char*]{.em}	[to_st ring]{.functionname}[ ()]{.functionargs}
	::: dox Inverse of the from-string constructor ::

↠ ARDOUR:DelayLine

C‡: std::shared_ptr< ARDOUR::DelayLine >, std::weak_ptr< ARDOUR::DelayLine >

is-a: ARDOUR:Processor

Methods
long	delay ()
bool	isnil ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:Delivery

C‡: std::shared_ptr< ARDOUR::Delivery >, std::weak_ptr< ARDOUR::Delivery >

is-a: ARDOUR:IOProcessor

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
PannerShell	panner_shell ()

Inherited from ARDOUR:IOProcessor

Methods
IO	input ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
IO	output ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:DeviceStatus

C‡: ARDOUR::AudioBackend::DeviceStatus

used to list device names along with whether or not they are currently available.

Data Members
bool	available
std::string	name

∁ ARDOUR:DeviceStatusVector

C‡: std::vector<ARDOUR::AudioBackend::DeviceStatus >

Constructor
ℂ	ARDOUR.DeviceStatusVector ()
ℂ	ARDOUR.DeviceStatusVector ()
Methods
LuaTable	add (LuaTable {DeviceStatus})
DeviceStatus	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (DeviceStatus)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

↠ ARDOUR:DiskIOProcessor

C‡: std::shared_ptr< ARDOUR::DiskIOProcessor >, std::weak_ptr< ARDOUR::DiskIOProcessor >

is-a: ARDOUR:Processor

Methods
bool	isnil ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:DiskReader

C‡: std::shared_ptr< ARDOUR::DiskReader >, std::weak_ptr< ARDOUR::DiskReader >

is-a: ARDOUR:DiskIOProcessor

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:DiskWriter

C‡: std::shared_ptr< ARDOUR::DiskWriter >, std::weak_ptr< ARDOUR::DiskWriter >

is-a: ARDOUR:DiskIOProcessor

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:EventList

C‡: std::list<Evoral::ControlEvent* >

Constructor
ℂ	ARDOUR.EventList ()
Methods
ControlEvent	back ()
bool	empty ()
ControlEvent	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:EventPtrList

C‡: std::list<std::shared_ptr<Evoral::Event<Temporal::Beats> > > >

Constructor
ℂ	ARDOUR.EventPtrList ()
Methods
LuaTable	add (LuaTable {Beats})
EventPtr	back ()
void	clear ()
bool	empty ()
EventPtr	front ()
LuaIter	iter ()
void	push_back (EventPtr)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

↠ ARDOUR:FileSource

C‡: std::shared_ptr< ARDOUR::FileSource >, std::weak_ptr< ARDOUR::FileSource >

is-a: ARDOUR:Source

Methods
unsigned short	channel ()
float	gain ()
bool	isnil ()
std::string	origin ()
std::string	path ()
std::string	take_id ()
bool	within_session ()

Inherited from ARDOUR:Source

Methods
std::string	ancestor_name ()
bool	can_be_analysed ()
XrunPositions	captured_xruns ()
bool	empty ()
bool	has_been_analysed ()
timepos_t	length ()
timepos_t	natural_position ()
timepos_t	timeline_position ()
long	timestamp ()
int	use_count ()
bool	used ()
bool	writable ()
Cast
AudioSource	to_audiosource ()
FileSource	to_filesource ()
MidiSource	to_midisource ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:FluidSynth

C‡: ARDOUR::FluidSynth

Constructor
ℂ	[ARDOUR.FluidS ynth]{.functionname}[ ([float]{.em}, [int]{ .em})]{.functionargs}
	::: dox instantiate a Synth samplerate : samplerate polyphony : polyphony ::
Methods
[bool]{.em}	[load _sf2]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[midi_e vent]{.functionname}[ ([unsigned char*]{.em}, [unsigned long]{ .em})]{.functionargs}
[void]{.em}	[p anic]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[program_c ount]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[program_ name]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[select_pro gram]{.functionname}[ ([unsigned int]{.em}, [unsigned char]{ .em})]{.functionargs}
[bool]{.em}	[s ynth]{.functionname}[ ([FloatA rray](#C:FloatArray), [FloatA rray](#C:FloatArray), [unsigned int]{ .em})]{.functionargs}

↠ ARDOUR:GainControl

C‡: std::shared_ptr< ARDOUR::GainControl >, std::weak_ptr< ARDOUR::GainControl >

is-a: ARDOUR:SlavableAutomationControl

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:SlavableAutomationControl

Methods
void	add_master (AutomationControl)
void	clear_masters ()
int	get_boolean_masters ()
double	get_masters_value ()
void	remove_master (AutomationControl)
bool	slaved ()
bool	slaved_to (AutomationControl)

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:IDMap

C‡: std::map<PBD::ID, PBD::ID >

Constructor
ℂ	ARDOUR.IDMap ()
Methods
LuaTable	add (PBD::ID, PBD::ID )
.…	at (–lua–)
void	clear ()
unsigned long	count (ID)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:IDNameMap

C‡: std::map<PBD::ID, std::string >

Constructor
ℂ	ARDOUR.IDNameMap ()
Methods
LuaTable	add (PBD::ID, std::string )
.…	at (–lua–)
void	clear ()
unsigned long	count (ID)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

↠ ARDOUR:IO

C‡: std::shared_ptr< ARDOUR::IO >, std::weak_ptr< ARDOUR::IO >

is-a: ARDOUR:SessionObjectPtr

A collection of ports (all input or all output) with connections.

An IO can contain ports of varying types, making routes/inserts/etc with varied combinations of types (eg MIDI and audio) possible.

Methods
bool	active ()
int	add_port (std::string, DataType)
AudioPort	audio (unsigned int)
int	connect (Port, std::string)
int	disconnect (Port, std::string)
int	disconnect_all ()
bool	has_port (Port)
bool	isnil ()
long	latency ()
MidiPort	midi (unsigned int)
ChanCount	n_ports ()
Port	nth (unsigned int)
bool	physically_connected ()
Port	port_by_name (unsigned int)
long	public_latency ()
int	remove_port (Port)

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:IOProcessor

C‡: std::shared_ptr< ARDOUR::IOProcessor >, std::weak_ptr< ARDOUR::IOProcessor >

is-a: ARDOUR:Processor

Methods
IO	input ()
bool	isnil ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
IO	output ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:InterThreadInfo

C‡: ARDOUR::InterThreadInfo

Constructor
ℂ	ARDOUR.InterThreadInfo ()
Data Members
bool	done
float	progress

↠ ARDOUR:InternalReturn

C‡: std::shared_ptr< ARDOUR::InternalReturn >, std::weak_ptr< ARDOUR::InternalReturn >

is-a: ARDOUR:Return

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:IOProcessor

Methods
IO	input ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
IO	output ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:InternalSend

C‡: std::shared_ptr< ARDOUR::InternalSend >, std::weak_ptr< ARDOUR::InternalSend >

is-a: ARDOUR:Send

Base class for objects with saveable and undoable state

Methods
bool	allow_feedback ()
std::string	display_name ()
bool	feeds (Route)
bool	isnil ()
void	set_allow_feedback (bool)
bool	set_name (std::string)
Route	source_route ()
Route	target_route ()

Inherited from ARDOUR:Send

Methods
GainControl	gain_control ()
long	get_delay_in ()
long	get_delay_out ()
bool	is_foldback ()
void	set_remove_on_disconnect (bool)
Cast
InternalSend	to_internalsend ()

Inherited from ARDOUR:Delivery

Methods
PannerShell	panner_shell ()

Inherited from ARDOUR:IOProcessor

Methods
IO	input ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
IO	output ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:LatencyRange

C‡: ARDOUR::LatencyRange

Constructor
ℂ	ARDOUR.LatencyRange ()
Data Members
unsigned int	max
unsigned int	min

↠ ARDOUR:Latent

C‡: std::shared_ptr< ARDOUR::Latent >, std::weak_ptr< ARDOUR::Latent >

Methods
long	effective_latency ()
bool	isnil ()
void	set_user_latency (long)
void	unset_user_latency ()
long	user_latency ()

∁ ARDOUR:Location

C‡: ARDOUR::Location

is-a: PBD:StatefulDestructible

Location on Timeline - abstract representation for Markers, Loop/Punch Ranges, CD-Markers etc.

Methods
[timepos_t] (#Temporal:timepos_t)	[_end]{.functionname}[ ()]{.functionargs}
[Flags](#A RDOUR.Location.Flags)	[f lags]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_auto_ loop]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_auto_p unch]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_cd_ma rker]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_clock_or igin]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_cue_ma rker]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_hi dden]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_ mark]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_range_ma rker]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_s cene]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_sec tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_session_r ange]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_ skip]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_skip ping]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_ xrun]{.functionname}[ ()]{.functionargs}
[timecnt_t] (#Temporal:timecnt_t)	[le ngth]{.functionname}[ ()]{.functionargs}
[void]{.em}	[ lock]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[lo cked]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[mat ches]{.functionname}[ ([Flags ](#ARDOUR.Location.Fl ags))]{.functionargs}
[int]{.em}	[mov e_to]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
[int]{.em}	[set]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[int]{.em}	[set _end]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [bool]{ .em})]{.functionargs}
[int]{.em}	[set_le ngth]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Set location name ::
[int]{.em}	[set_s tart]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [bool]{ .em})]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[s tart]{.functionname}[ ()]{.functionargs}
[void]{.em}	[un lock]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:LocationList

C‡: std::list<ARDOUR::Location* >

Constructor
ℂ	ARDOUR.LocationList ()
Methods
Location	back ()
bool	empty ()
Location	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:Locations

C‡: ARDOUR::Locations

is-a: PBD:StatefulDestructible

Methods
Location	add_range (timepos_t, timepos_t)
Location	auto_loop_location ()
Location	auto_punch_location ()
LuaTable(.…)	find_all_between (timepos_t, timepos_t, LocationList&, Flags)
timepos_t	first_mark_after (timepos_t, bool)
Location	first_mark_at (timepos_t, timecnt_t, Flags)
timepos_t	first_mark_before (timepos_t, bool)
LocationList	list ()
Location	mark_at (timepos_t, timecnt_t, Flags)
LuaTable(.…)	marks_either_side (timepos_t, timepos_t&, timepos_t&)
LuaTable(Location, .…)	next_section (Location, timepos_t&, timepos_t&)
Location	range_starts_at (timepos_t, timecnt_t, bool)
void	remove (Location)
Location	session_range_location ()

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

ℕ ARDOUR.LuaAPI

Methods
[std::string]{.em}	[ascii_dt ostr]{.functionname}[ ([double]{ .em})]{.functionargs}
[...]{.em}	[build_file name]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox Creates a filename from a series of elements using the correct separator for filenames. No attempt is made to force the resulting filename to be an absolute path. If the first element is a relative path, the result will be a relative path. ::
[...]{.em}	[color_to_ rgba]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox A convenience function to expand RGBA parameters from an integer convert a Canvas::Color (uint32_t 0xRRGGBBAA) into double RGBA values which can be passed as parameters to Cairo::Con text::set_source_rgba Example: local r, g, b, a = ARDOUR.LuaAPI.color _to_rgba (0x88aa44ff) cair o_ctx:set_source_rgba (ARDOUR.LuaAPI.color _to_rgba (0x11336699) ::: result-discussion [Re turns]{.word-returns} 4 parameters: red, green, blue, alpha (in range 0..1) ::: ::
[...]{.em}	[desc_scale_po ints]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
[std::string]{.em}	[dump_untagged_plu gins]{.functionname}[ ()]{.functionargs}
	::: dox Write a list of untagged plugins to a file, so we can bulk-tag them ::: result-discussion [Re turns]{.word-returns} path to XML file or empty string on error ::: ::
[StringVec tor](#C:StringVector)	[env]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[file_get_cont ents]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[file_ test]{.functionname}[ ([std::string]{.em}, [ FileTest](#Glib.FileT est))]{.functionargs}
*Lu aTable*([float]{.em}, ...)	[get_plugin_insert_p aram]{.functionname}[ ([PluginInsert](# ARDOUR:PluginInsert), [unsigned int]{.em}, [bool&]{ .em})]{.functionargs}
	::: dox get a plugin control parameter value pi : Plugin-Insert which : control port to query (starting at 0, including ports of type input and output) ok : boolean variable contains true or false after call returned. to be checked by caller before using value. ::: result-discussion [Re turns]{.word-returns} value ::: ::
[...]{.em}	[g et_plugin_insert_prop erty]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox get a plugin property (LV2 plugins only) L : two arguments: Plugin-Insert, URI of the property ::: result-discussion [Re turns]{.word-returns} value, depending on datatype or nil if property is not found ::: ::
*Lu aTable*([float]{.em}, ...)	[get_processor_p aram]{.functionname}[ ([Processor ](#ARDOUR:Processor), [unsigned int]{.em}, [bool&]{ .em})]{.functionargs}
	::: dox get a plugin control parameter value proc : Plugin-Processor which : control port to set (starting at 0, including ports of type input and output)) ok : boolean variable contains true or false after call returned. to be checked by caller before using value. ::: result-discussion [Re turns]{.word-returns} value ::: ::
[...]{.em}	[hsla_to_ rgba]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox A convenience function for colorspace HSL to RGB conversion. All ranges are 0..1 Example: local r, g, b, a = ARDOUR.LuaAPI.hsla_to _rgba (hue, saturatio n, luminosity, alpha) ::: result-discussion [Re turns]{.word-returns} 4 parameters: red, green, blue, alpha (in range 0..1) ::: ::
[PluginInfoList](#A RDOUR:PluginInfoList)	[list_plu gins]{.functionname}[ ()]{.functionargs}
[long]{.em}	[monotonic_ time]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[new_lua proc]{.functionname}[ ([Sessi on](#ARDOUR:Session), [std::string]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[new _luaproc_with_time_do main]{.functionname}[ ([Sessi on](#ARDOUR:Session), [std::string]{.em}, [TimeDoma in](#Temporal.TimeDom ain))]{.functionargs}
	::: dox create a new Lua Processor (Plugin) s : Session Handle p : Identifier or Name of the Processor td : Time domain (audio or beats) for any automation data ::: result-discussion [Re turns]{.word-returns} Processor object (may be nil) ::: ::
[Note Ptr](#Evoral:NotePtr)	[new_not eptr]{.functionname}[ ([unsigned char]{.em}, [Bea ts](#Temporal:Beats), [Bea ts](#Temporal:Beats), [unsigned char]{.em}, [unsigned char]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[new_pl ugin]{.functionname}[ ([Sessi on](#ARDOUR:Session), [std::string]{.em}, [PluginType] (#ARDOUR:PluginType), [std::string]{ .em})]{.functionargs}
[PluginInfo ](#ARDOUR:PluginInfo)	[new_plugin_ info]{.functionname}[ ([std::string]{.em}, [Plugin Type](#ARDOUR:PluginT ype))]{.functionargs}
	::: dox search a Plugin id : Plugin Name, ID or URI type : Plugin Type ::: result-discussion [Re turns]{.word-returns} PluginInfo or nil if not found ::: ::
[Processo r](#ARDOUR:Processor)	[ne w_plugin_with_time_do main]{.functionname}[ ([Sessi on](#ARDOUR:Session), [std::string]{.em}, [PluginType] (#ARDOUR:PluginType), [TimeDomain](# Temporal.TimeDomain), [std::string]{ .em})]{.functionargs}
	::: dox create a new Plugin Instance s : Session Handle id : Plugin Name, ID or URI type : Plugin Type td : Time domain for any automation data preset : name of plugin-preset to load, leave empty "" to not load any preset after instantiation ::: result-discussion [Re turns]{.word-returns} Processor or nil ::: ::
[Processo r](#ARDOUR:Processor)	[new_ send]{.functionname}[ ([Sessi on](#ARDOUR:Session), [R oute](#ARDOUR:Route), [Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nil_ proc]{.functionname}[ ()]{.functionargs}
[NotePtrList] (#ARDOUR:NotePtrList)	[note_ list]{.functionname}[ ([Midi Model](#ARDOUR:MidiMo del))]{.functionargs}
[Patch ChangePtrList](#ARDOU R:PatchChangePtrList)	[patch_change_ list]{.functionname}[ ([Midi Model](#ARDOUR:MidiMo del))]{.functionargs}
[std::string]{.em}	[path_get_base name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[...]{.em}	[plugin_automa tion]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox A convenience function to get a Automation Lists and ParameterDescriptor for a given plugin control. This is equivalent to the following lua code function (processor, param_id) l ocal plugininsert = p rocessor:to_insert () local plugin = p lugininsert:plugin(0) l ocal _, t = plugin:ge t_parameter_descripto r(param_id, ARDOUR.Pa rameterDescriptor ()) local ctrl = Evoral. Parameter (ARDOUR.Aut omationType.PluginAut omation, 0, param_id) loca l ac = pi:automation_ control (ctrl, false) l ocal acl = ac:alist() re turn ac:alist(), ac:t o_ctrl():list(), t[2] end Example usage: get the third input parameter of first plugin on the given route (Ardour starts counting at zero). local al, cl, pd = ARDOUR.LuaAPI.p lugin_automation (rou te:nth_plugin (0), 3) ::: result-discussion [Re turns]{.word-returns} 3 parameters: AutomationList, ControlList, ParameterDescriptor ::: ::
[bool]{.em}	[r eset_processor_to_def ault]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox reset a processor to its default values (only works for plugins ) This is a wrapper which looks up the Processor by plugin-insert. proc : Plugin-Insert ::: result-discussion [Re turns]{.word-returns} true on success, false when the processor is not a plugin ::: ::
[...]{.em}	[sample_to_time code]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox Generic conversion from audio sample count to timecode. (TimecodeType, sample-rate, sample-pos) ::
[void]{.em}	[segf ault]{.functionname}[ ()]{.functionargs}
	::: dox Crash Test Dummy ::
[bool]{.em}	[set_automation_ data]{.functionname}[ ([Auto mationControl](#ARDOU R:AutomationControl), Lua-Function, [double]{ .em})]{.functionargs}
[bool]{.em}	[set_plugin_insert_p aram]{.functionname}[ ([PluginInsert](# ARDOUR:PluginInsert), [unsigned int]{.em}, [float]{ .em})]{.functionargs}
	::: dox set a plugin control-input parameter value This is a wrapper around set_processor_param which looks up the Processor by plugin-insert. pi : Plugin-Insert which : control-input to set (starting at 0) value : value to set ::: result-discussion [Re turns]{.word-returns} true on success, false on error or out-of-bounds value ::: ::
[bool]{.em}	[s et_plugin_insert_prop erty]{.functionname}[ ([PluginInsert](# ARDOUR:PluginInsert), [std::string]{.em}, Lua-Func tion)]{.functionargs}
	::: dox set a plugin property (LV2 plugins only) pi : Plugin-Insert uri : the identifier of the parameter value : the value to set (boolean, integer, float, string/path) ::: result-discussion [Re turns]{.word-returns} true on success, false if the given plugin has no property with the given URI ::: ::
[bool]{.em}	[set_processor_p aram]{.functionname}[ ([Processor ](#ARDOUR:Processor), [unsigned int]{.em}, [float]{ .em})]{.functionargs}
	::: dox set a plugin control-input parameter value proc : Plugin-Processor which : control-input to set (starting at 0) value : value to set ::: result-discussion [Re turns]{.word-returns} true on success, false on error or out-of-bounds value ::: ::
[EventPtrList]( #ARDOUR:EventPtrList)	[sysex_ list]{.functionname}[ ([Midi Model](#ARDOUR:MidiMo del))]{.functionargs}
[...]{.em}	[timecode_to_sa mple]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox Generic conversion from timecode to audio sample count. (TimecodeType, sample-rate, hh, mm, ss, ff) ::
[void]{.em}	[us leep]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
[bool]{.em}	[ wait_for_process_call back]{.functionname}[ ([unsigned long]{.em}, [long]{ .em})]{.functionargs}
	::: dox Delay execution until next process cycle starts. n_cycles : process-cycles to wait for. 0: means wait until next cycle-start, otherwise skip given number of cycles. timeout_ms : wait at most this many milliseconds ::: result-discussion [Re turns]{.word-returns} true on success, false if timeout was reached or engine was not running ::: ::

∁ ARDOUR:LuaAPI:Rubberband

C‡: ARDOUR::LuaAPI::Rubberband

Constructor
ℂ	ARDOUR.LuaAPI.Rubberband (AudioRegion, bool)
Methods
unsigned int	n_channels ()
AudioRegion	process (Lua-Function)
Readable	readable ()
long	readable_length ()
bool	set_mapping (Lua-Function)
bool	set_strech_and_pitch (double, double)

∁ ARDOUR:LuaAPI:Vamp

C‡: ARDOUR::LuaAPI::Vamp

Constructor
ℂ	[ARDOUR.LuaAPI. Vamp]{.functionname}[ ([std::string]{.em}, [float]{ .em})]{.functionargs}
Methods
[int]{.em}	[ana lyze]{.functionname}[ ([Readabl e](#ARDOUR:Readable), [unsigned int]{.em}, Lua-Func tion)]{.functionargs}
	::: dox high-level abstraction to process a single channel of the given AudioReadable. If the plugin is not yet initialized, initialize() is called. if fn is not nil, it is called with the immediate V amp::Plugin::Features on every process call. r : readable channel : channel to process cb : lua callback function or nil ::: result-discussion [Re turns]{.word-returns} 0 on success ::: ::
[bool]{.em}	[initia lize]{.functionname}[ ()]{.functionargs}
	::: dox initialize the plugin for use with analyze(). This is equivalent to plugin():initialise (1, ssiz, bsiz) and prepares a plugin for analyze. (by preferred step and block sizes are used. if the plugin does not specify them or they're larger than 8K, both are set to 1024) Manual initialization is only required to set plugin-parameters which depend on prior initialization of the plugin. vamp:reset () vamp:initialize () vamp:plugin():setPa rameter (0, 1.5, nil) vamp:analyze (r, 0) ::
[StringVec tor](#C:StringVector)	[list_plu gins]{.functionname}[ ()]{.functionargs}
[ Plugin](#Vamp:Plugin)	[pl ugin]{.functionname}[ ()]{.functionargs}
[FeatureSet](#Va mp:Plugin:FeatureSet)	[pro cess]{.functionname}[ ([FloatArrayVector]( #C:FloatArrayVector), [ RealTime](#Vamp:RealT ime))]{.functionargs}
[void]{.em}	[r eset]{.functionname}[ ()]{.functionargs}
	::: dox call plugin():reset() and clear initialization flag ::

∁ ARDOUR:LuaOSC:Address

C‡: ARDOUR::LuaOSC::Address

OSC transmitter

A Class to send OSC messages.

Constructor
ℂ	[ARDOUR.LuaOSC.Add ress]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Construct a new OSC transmitter object uri : the destination uri e.g. "osc.u dp://localhost:7890" ::
Methods
...	[ send]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox Transmit an OSC message Path (string) and type (string) must always be given. The number of following args must match the type. Supported types are: 'i': integer (lua number) 'f': float (lua number) 'd': double (lua number) 'h': 64bit integer (lua number) 's': string (lua string) 'c': character (lua string) 'T': boolean (lua bool) -- this is not implicily True, a lua true/false must be given 'F': boolean (lua bool) -- this is not implicily False, a lua true/false must be given lua: : lua arguments: path, types, ... ::: result-discussion [Re turns]{.word-returns} boolean true if successful, false on error. ::: ::

↠ ARDOUR:LuaProc

C‡: std::shared_ptr< ARDOUR::LuaProc >, std::weak_ptr< ARDOUR::LuaProc >

is-a: ARDOUR:Plugin

Methods
bool	isnil ()
DspShm	shmem ()
LuaTableRef	table ()

Inherited from ARDOUR:Plugin

Methods
[float]{.em}	[default_v alue]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[IOPortDesc ription](#ARDOUR:Plug in:IOPortDescription)	[describe_io_ port]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [bool]{.em}, [unsigned int]{ .em})]{.functionargs}
[std::string]{.em}	[get_ docs]{.functionname}[ ()]{.functionargs}
[PluginInfo ](#ARDOUR:PluginInfo)	[get_ info]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_param eter]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
LuaTable*([int]{.em}, ...)	[get_parameter_descri ptor]{.functionname}[ ([unsigned int]{.em}, [Para meterDescriptor&](#AR DOUR:ParameterDescrip tor))]{.functionargs}
[std::string]{.em}	[get_parameter_ docs]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[char*]{.em}	[l abel]{.functionname}[ ()]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[last_pr eset]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Last preset to be requested; the settings may have been changed since; find out with parameter_chang ed_since_last_preset. ::: ::
[bool]{.em}	[load_pr eset]{.functionname}[ ([PresetReco rd](#ARDOUR:PresetRec ord))]{.functionargs}
[char*]{.em}	[m aker]{.functionname}[ ()]{.functionargs}
[char*]{.em}	[ name]{.functionname}[ ()]{.functionargs}
*LuaTable*([unsigned int]{.em}, ...)	[nth_param eter]{.functionname}[ ([unsigned int]{.em}, [bool&]{ .em})]{.functionargs}
[unsigned int]{.em}	[parameter_c ount]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[parameter_is_a udio]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[parameter_is_con trol]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[parameter_is_i nput]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[parameter_is_ou tput]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[std::string]{.em}	[parameter_l abel]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[preset_by_l abel]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[preset_by _uri]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[void]{.em}	[remove_pr eset]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[save_pr eset]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Create a new plugin-preset from the current state name : label to use for new preset (needs to be unique) ::: result-discussion [Re turns]{.word-returns} PresetRecord with empty URI on failure ::: ::
[std::string]{.em}	[uniqu e_id]{.functionname}[ ()]{.functionargs}
Cast
[LuaP roc](#ARDOUR:LuaProc)	[to_lua proc]{.functionname}[ ()]{.functionargs}

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:LuaTableRef

C‡: ARDOUR::LuaTableRef

Methods
.…	get (–lua–)
.…	set (–lua–)

∁ ARDOUR:MIDIPortMeters

C‡: std::map<std::string, ARDOUR::PortManager::MPM >

Constructor
ℂ	ARDOUR.MIDIPortMeters ()
Methods
LuaTable	add (std::string, ARDOUR::PortManager::MPM )
.…	at (–lua–)
void	clear ()
unsigned long	count (std::string)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

↠ ARDOUR:MPGainControl

C‡: std::shared_ptr< ARDOUR::MPControl<float> >, std::weak_ptr< ARDOUR::MPControl<float> >

is-a: PBD:Controllable

Methods
std::string	get_user_string ()
double	get_value ()
bool	isnil ()
double	lower ()
double	normal ()
void	set_value (double, GroupControlDisposition)
double	upper ()

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:MPToggleControl

C‡: std::shared_ptr< ARDOUR::MPControl<bool> >, std::weak_ptr< ARDOUR::MPControl<bool> >

is-a: PBD:Controllable

Methods
std::string	get_user_string ()
double	get_value ()
bool	isnil ()
double	lower ()
double	normal ()
void	set_value (double, GroupControlDisposition)
double	upper ()

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:MidiBuffer

C‡: ARDOUR::MidiBuffer

Buffer containing 8-bit unsigned char (MIDI) data.

Methods
[void]{.em}	[ copy]{.functionname}[ ([MidiBu ffer](#ARDOUR:MidiBuf fer))]{.functionargs}
[bool]{.em}	[e mpty]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[push_ back]{.functionname}[ ([long]{.em}, [EventType ](#Evoral.EventType), [unsigned long]{.em}, [unsigned char*]{ .em})]{.functionargs}
[bool]{.em}	[push_e vent]{.functionname}[ ([Event](#Evoral:Ev ent))]{.functionargs}
[void]{.em}	[re size]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
	::: dox Reallocate the buffer used internally to handle at least size_t units of data. The buffer is not silent after this operation. the capacity argument passed to the constructor must have been non-zero. ::
[void]{.em}	[sil ence]{.functionname}[ ([long]{.em}, [long]{ .em})]{.functionargs}
	::: dox Clear (eg zero, or empty) buffer ::
[unsigned long]{.em}	[ size]{.functionname}[ ()]{.functionargs}
...	[t able]{.functionname}[ ([--lua--]{ .em})]{.functionargs}

↠ ARDOUR:MidiModel

C‡: std::shared_ptr< ARDOUR::MidiModel >, std::weak_ptr< ARDOUR::MidiModel >

is-a: ARDOUR:AutomatableSequence

Methods
[void]{.em}	[apply_com mand]{.functionname}[ ([HistoryOwner ](#PBD:HistoryOwner), [Command](#PBD:Comm and))]{.functionargs}
[void]{.em}	[app ly_diff_command_as_co mmit]{.functionname}[ ([HistoryOwner ](#PBD:HistoryOwner), [Command](#PBD:Comm and))]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[NoteDiffC ommand](#ARDOUR:MidiM odel:NoteDiffCommand)	[new_note_diff_com mand]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Start a new NoteDiff command. This has no side-effects on the model or Session, the returned command can be held on to for as long as the caller wishes, or discarded without formality, until a pply_diff_command_* is called and ownership is taken. ::
[NoteDiffC ommand](#ARDOUR:MidiM odel:NoteDiffCommand)	[new_ patch_change_diff_com mand]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Start a new PatchChangeDiff command ::
[NoteDiffC ommand](#ARDOUR:MidiM odel:NoteDiffCommand)	[new_sysex_diff_com mand]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Start a new SysExDiff command ::

Inherited from ARDOUR:AutomatableSequence

Cast
Sequence	to_sequence ()

Inherited from ARDOUR:Automatable

Methods
[ParameterList](# ARDOUR:ParameterList)	[all_automatable_pa rams]{.functionname}[ ()]{.functionargs}
	::: dox API for Lua binding ::
[Aut omationControl](#ARDO UR:AutomationControl)	[automation_con trol]{.functionname}[ ([Parameter ](#Evoral:Parameter), [bool]{ .em})]{.functionargs}
Cast
[Slavab le](#ARDOUR:Slavable)	[to_slav able]{.functionname}[ ()]{.functionargs}

∅ ARDOUR:MidiModel:DiffCommand

C‡: ARDOUR::MidiModel::DiffCommand

is-a: PBD:Command

Base class for Undo/Redo commands and changesets

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from PBD:Command

Methods
std::string	name ()
void	set_name (std::string)

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:MidiModel:NoteDiffCommand

C‡: ARDOUR::MidiModel::PatchChangeDiffCommand

is-a: ARDOUR:MidiModel:DiffCommand

Methods
void	add (NotePtr)
void	add (PatchChangePtr)
void	change (EventPtr, Beats)
void	remove (NotePtr)
void	remove (EventPtr)
void	remove (PatchChangePtr)

Inherited from PBD:Command

Methods
std::string	name ()
void	set_name (std::string)

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:MidiPlaylist

C‡: std::shared_ptr< ARDOUR::MidiPlaylist >, std::weak_ptr< ARDOUR::MidiPlaylist >

is-a: ARDOUR:Playlist

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
void	set_note_mode (NoteMode)

Inherited from ARDOUR:Playlist

Methods
void	add_region (Region, timepos_t, float, bool)
Region	combine (RegionList, Track)
unsigned int	count_regions_at (timepos_t)
Playlist	cut (TimelineRangeList&)
DataType	data_type ()
void	duplicate (Region, timepos_t&, timecnt_t, float)
void	duplicate_range (TimelineRange&, float)
void	duplicate_until (Region, timepos_t&, timecnt_t, timepos_t)
bool	empty ()
Region	find_next_region (timepos_t, RegionPoint, int)
timepos_t	find_next_region_boundary (timepos_t, int)
long	find_next_transient (timepos_t, int)
ID	get_orig_track_id ()
bool	hidden ()
void	lower_region (Region)
void	lower_region_to_bottom (Region)
unsigned int	n_regions ()
void	raise_region (Region)
void	raise_region_to_top (Region)
Region	region_by_id (ID)
RegionListPtr	region_list ()
RegionListPtr	regions_at (timepos_t)
RegionListPtr	regions_touched (timepos_t, timepos_t)
RegionListPtr	regions_with_end_within (Range)
RegionListPtr	regions_with_start_within (Range)
void	remove_region (Region)
bool	set_name (std::string)
bool	shared ()
void	split_region (Region, timepos_t)
Region	top_region_at (timepos_t)
Region	top_unmuted_region_at (timepos_t)
void	uncombine (Region)
bool	used ()
Cast
AudioPlaylist	to_audioplaylist ()
MidiPlaylist	to_midiplaylist ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:MidiPort

C‡: std::shared_ptr< ARDOUR::MidiPort >, std::weak_ptr< ARDOUR::MidiPort >

is-a: ARDOUR:Port

Methods
MidiBuffer	get_midi_buffer (unsigned int)
bool	input_active ()
bool	isnil ()
void	set_input_active (bool)
Cast
AsyncMIDIPort	to_asyncmidiport ()

Inherited from ARDOUR:Port

Methods
[int]{.em}	[con nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[conne cted]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this port is connected to anything ::: ::
[bool]{.em}	[connecte d_to]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox o : Port name ::: result-discussion [Re turns]{.word-returns} true if this port is connected to o, otherwise false. ::: ::
[int]{.em}	[discon nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[disconnect _all]{.functionname}[ ()]{.functionargs}
[PortFlag s](#ARDOUR.PortFlags)	[f lags]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} flags ::: ::
*LuaTable*(...)	[ge t_connected_latency_r ange]{.functionname}[ ([LatencyRange&](# ARDOUR:LatencyRange), [bool]{ .em})]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port short name ::: ::
[bool]{.em}	[physically_conne cted]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[pretty_ name]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port human readable name ::: ::
[LatencyRange]( #ARDOUR:LatencyRange)	[private_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[LatencyRange]( #ARDOUR:LatencyRange)	[public_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[receives_i nput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port receives input, otherwise false ::: ::
[bool]{.em}	[sends_ou tput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port sends output, otherwise false ::: ::
Cast
[AsyncMIDIPort](# ARDOUR:AsyncMIDIPort)	[to_asyncmidi port]{.functionname}[ ()]{.functionargs}
[AudioPor t](#ARDOUR:AudioPort)	[to_audio port]{.functionname}[ ()]{.functionargs}
[MidiPo rt](#ARDOUR:MidiPort)	[to_midi port]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:MidiRegion

C‡: std::shared_ptr< ARDOUR::MidiRegion >, std::weak_ptr< ARDOUR::MidiRegion >

is-a: ARDOUR:Region

Base class for objects with saveable and undoable state

Methods
[bool]{.em}	[do_ex port]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Export the MIDI data of the MidiRegion to a new MIDI file (SMF). ::
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[MidiSource ](#ARDOUR:MidiSource)	[midi_so urce]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[MidiMode l](#ARDOUR:MidiModel)	[m odel]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Region

Methods
[bool]{.em}	[add_pl ugin]{.functionname}[ ([RegionFxPlugin](#AR DOUR:RegionFxPlugin), [RegionFxPlugin ](#ARDOUR:RegionFxPlu gin))]{.functionargs}
[bool]{.em}	[at_natural_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[autom atic]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[can_ move]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[capt ured]{.functionname}[ ()]{.functionargs}
[void]{.em}	[captured_x runs]{.functionname}[ ([XrunPositions&](#A RDOUR:XrunPositions), [bool]{ .em})]{.functionargs}
[void]{.em}	[clear_sync_posi tion]{.functionname}[ ()]{.functionargs}
[Cont rol](#Evoral:Control)	[con trol]{.functionname}[ ([Parameter ](#Evoral:Parameter), [bool]{ .em})]{.functionargs}
[bool]{.em}	[co vers]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[cut _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[cut_f ront]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[DataTy pe](#ARDOUR:DataType)	[data_ type]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[exte rnal]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[has_transi ents]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[hi dden]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[im port]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_comp ound]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[l ayer]{.functionname}[ ()]{.functionargs}
[timecnt_t] (#Temporal:timecnt_t)	[le ngth]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[load_pl ugin]{.functionname}[ ([PluginType] (#ARDOUR:PluginType), [std::string]{ .em})]{.functionargs}
[bool]{.em}	[lo cked]{.functionname}[ ()]{.functionargs}
[void]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[void]{.em}	[lower_to_bo ttom]{.functionname}[ ()]{.functionargs}
[StringVec tor](#C:StringVector)	[master_source_n ames]{.functionname}[ ()]{.functionargs}
[SourceList ](#ARDOUR:SourceList)	[master_sou rces]{.functionname}[ ()]{.functionargs}
[void]{.em}	[move_s tart]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[void]{.em}	[move_to_natural_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[m uted]{.functionname}[ ()]{.functionargs}
[RegionFxPlugin](#A RDOUR:RegionFxPlugin)	[nth_pl ugin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[void]{.em}	[nudge_posi tion]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[bool]{.em}	[op aque]{.functionname}[ ()]{.functionargs}
[Playli st](#ARDOUR:Playlist)	[play list]{.functionname}[ ()]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[posi tion]{.functionname}[ ()]{.functionargs}
	::: dox How the region parameters play together: POSITION: first sample of the region along the timeline START: first sample of the region within its source(s) LENGTH: number of samples the region represents ::
[bool]{.em}	[position_lo cked]{.functionname}[ ()]{.functionargs}
[void]{.em}	[r aise]{.functionname}[ ()]{.functionargs}
[void]{.em}	[raise_to _top]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[remove_pl ugin]{.functionname}[ ([RegionFxPlugin](#AR DOUR:RegionFxPlugin), [RegionFxPlugin ](#ARDOUR:RegionFxPlu gin))]{.functionargs}
[void]{.em}	[set_hi dden]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_initial_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_le ngth]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[void]{.em}	[set_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_m uted]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Note: changing the name of a Region does not constitute an edit ::
[void]{.em}	[set_op aque]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_position_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_s tart]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_sync_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_video_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[float]{.em}	[s hift]{.functionname}[ ()]{.functionargs}
[So urce](#ARDOUR:Source)	[so urce]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[s tart]{.functionname}[ ()]{.functionargs}
[float]{.em}	[str etch]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[sync_ma rked]{.functionname}[ ()]{.functionargs}
*L uaTable*([timecnt_t]( #Temporal:timecnt_t), ...)	[sync_of fset]{.functionname}[ ([int&]{ .em})]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[sync_posi tion]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Sync position in session time ::: ::
[Int 64List](#C:Int64List)	[transi ents]{.functionname}[ ()]{.functionargs}
[void]{.em}	[trim _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[trim_f ront]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[tri m_to]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[bool]{.em}	[video_lo cked]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[whole_ file]{.functionname}[ ()]{.functionargs}
Cast
[AudioRegion] (#ARDOUR:AudioRegion)	[to_audiore gion]{.functionname}[ ()]{.functionargs}
[MidiRegion ](#ARDOUR:MidiRegion)	[to_midire gion]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:MidiSource

C‡: std::shared_ptr< ARDOUR::MidiSource >, std::weak_ptr< ARDOUR::MidiSource >

is-a: ARDOUR:Source

Methods
bool	empty ()
bool	isnil ()
timepos_t	length ()
MidiModel	model ()

Inherited from ARDOUR:Source

Methods
std::string	ancestor_name ()
bool	can_be_analysed ()
XrunPositions	captured_xruns ()
bool	has_been_analysed ()
timepos_t	natural_position ()
timepos_t	timeline_position ()
long	timestamp ()
int	use_count ()
bool	used ()
bool	writable ()
Cast
AudioSource	to_audiosource ()
FileSource	to_filesource ()
MidiSource	to_midisource ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:MidiTrack

C‡: std::shared_ptr< ARDOUR::MidiTrack >, std::weak_ptr< ARDOUR::MidiTrack >

is-a: ARDOUR:Track

Base class for objects with saveable and undoable state

Methods
unsigned short	get_capture_channel_mask ()
ChannelMode	get_capture_channel_mode ()
ChannelMode	get_playback_channel_mask ()
ChannelMode	get_playback_channel_mode ()
bool	input_active ()
bool	isnil ()
void	set_capture_channel_mask (unsigned short)
void	set_capture_channel_mode (ChannelMode, unsigned short)
void	set_input_active (bool)
void	set_playback_channel_mask (unsigned short)
void	set_playback_channel_mode (ChannelMode, unsigned short)
bool	write_immediate_event (EventType, unsigned long, unsigned char*)

Inherited from ARDOUR:Track

Constructor
ℵ	[ARDOUR.T rack]{.functionname}[ ()]{.functionargs}
Methods
[Re gion](#ARDOUR:Region)	[bo unce]{.functionname}[ ([I nterThreadInfo&](#ARD OUR:InterThreadInfo), [std::string]{ .em})]{.functionargs}
[Re gion](#ARDOUR:Region)	[bounce_r ange]{.functionname}[ ([long]{.em}, [long]{.em}, [I nterThreadInfo&](#ARD OUR:InterThreadInfo), [Processor ](#ARDOUR:Processor), [bool]{.em}, [std::string]{.em}, [bool]{ .em})]{.functionargs}
[bool]{.em}	[bounce able]{.functionname}[ ([Processor ](#ARDOUR:Processor), [bool]{ .em})]{.functionargs}
	::: dox Test if the track can be bounced with the given settings. If sends/inserts/returns are present in the signal path or the given track has no audio outputs bouncing is not possible. endpoint : the processor to tap the signal off (or nil for the top) include_endpoint : include the given processor in the bounced audio. ::: result-discussion [Re turns]{.word-returns} true if the track can be bounced, or false otherwise. ::: ::
[bool]{.em}	[can_re cord]{.functionname}[ ()]{.functionargs}
[int]{.em}	[find_and_use_play list]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [ID](#PBD :ID))]{.functionargs}
[Playli st](#ARDOUR:Playlist)	[play list]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[use_copy_play list]{.functionname}[ ()]{.functionargs}
[int]{.em}	[use_new_play list]{.functionname}[ ([Da taType](#ARDOUR:DataT ype))]{.functionargs}
[int]{.em}	[use_play list]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [Playlis t](#ARDOUR:Playlist), [bool]{ .em})]{.functionargs}
Cast
[AudioTrack ](#ARDOUR:AudioTrack)	[to_audio_t rack]{.functionname}[ ()]{.functionargs}
[MidiTrac k](#ARDOUR:MidiTrack)	[to_midi_t rack]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Route

Methods
[bool]{.em}	[ac tive]{.functionname}[ ()]{.functionargs}
[int]{.em}	[add_aux_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox Add an aux send to a route. route : route to send to. before : Processor to insert before, or 0 to insert at the end. ::
[int]{.em}	[add_foldback_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [bool]{ .em})]{.functionargs}
[int]{.em}	[add_processor_by_i ndex]{.functionname}[ ([Processor ](#ARDOUR:Processor), [int]{.em}, [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[bool]{.em}	[add_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[Amp](#ARDOUR:Amp)	[amp]{.functionname}[ ()]{.functionargs}
[void]{.em}	[clear_stripa bles]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[com ment]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[customize_plugin_in sert]{.functionname}[ ([Processor ](#ARDOUR:Processor), [unsigned int]{.em}, [ChanCount ](#ARDOUR:ChanCount), [Chan Count](#ARDOUR:ChanCo unt))]{.functionargs}
[DataTy pe](#ARDOUR:DataType)	[data_ type]{.functionname}[ ()]{.functionargs}
[Stripabl e](#ARDOUR:Stripable)	[first_selected_strip able]{.functionname}[ ()]{.functionargs}
[IO](#ARDOUR:IO)	[i nput]{.functionname}[ ()]{.functionargs}
[Delive ry](#ARDOUR:Delivery)	[main_ outs]{.functionname}[ ()]{.functionargs}
[MonitorControl](#A RDOUR:MonitorControl)	[monitoring_con trol]{.functionname}[ ()]{.functionargs}
[MonitorState]( #ARDOUR.MonitorState)	[monitoring_s tate]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[m uted]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_in puts]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_out puts]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_pl ugin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_proce ssor]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_ send]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[IO](#ARDOUR:IO)	[ou tput]{.functionname}[ ()]{.functionargs}
[PannerShell] (#ARDOUR:PannerShell)	[panner_s hell]{.functionname}[ ()]{.functionargs}
[PeakMete r](#ARDOUR:PeakMeter)	[peak_m eter]{.functionname}[ ()]{.functionargs}
[long]{.em}	[playback_lat ency]{.functionname}[ ([bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[remove_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[int]{.em}	[reorder_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[int]{.em}	[replace_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processor ](#ARDOUR:Processor), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[reset_plugin_in sert]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox reset plugin-insert configuration to default, disable customizations. This is equivalent to calling customize_plugin_ins ert (proc, 0, unused) proc : Processor to reset ::: result-discussion [Re turns]{.word-returns} true if successful ::: ::
[int]{.em}	[save_as_temp late]{.functionname}[ ([std::string]{.em}, [std::string]{.em}, [std::string]{ .em})]{.functionargs}
[void]{.em}	[select_next_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[select_prev_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[set_ac tive]{.functionname}[ ([bool]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_com ment]{.functionname}[ ([std::string]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_meter_p oint]{.functionname}[ ([MeterP oint](#ARDOUR.MeterPo int))]{.functionargs}
[bool]{.em}	[set_stric t_io]{.functionname}[ ([bool]{ .em})]{.functionargs}
[long]{.em}	[signal_lat ency]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[so loed]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[stric t_io]{.functionname}[ ()]{.functionargs}
[SurroundReturn](#A RDOUR:SurroundReturn)	[surround_re turn]{.functionname}[ ()]{.functionargs}
[SurroundSend]( #ARDOUR:SurroundSend)	[surround_ send]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[the_instru ment]{.functionname}[ ()]{.functionargs}
	::: dox Return the first processor that accepts has at least one MIDI input and at least one audio output. In the vast majority of cases, this will be "the instrument". This does not preclude other MIDI->audio processors later in the processing chain, but that would be a special case not covered by this utility function. ::
[Amp](#ARDOUR:Amp)	[ trim]{.functionname}[ ()]{.functionargs}
Cast
[ Track](#ARDOUR:Track)	[to_t rack]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Stripable

Methods
unsigned int	eq_band_cnt ()
std::string	eq_band_name (unsigned int)
GainControl	gain_control ()
bool	is_auditioner ()
bool	is_hidden ()
bool	is_master ()
bool	is_monitor ()
bool	is_private_route ()
bool	is_selected ()
bool	is_surround_master ()
AutomationControl	mapped_control (WellKnownCtrl, unsigned int)
ReadOnlyControl	mapped_output (WellKnownData)
AutomationControl	master_send_enable_controllable ()
MonitorProcessor	monitor_control ()
MuteControl	mute_control ()
AutomationControl	pan_azimuth_control ()
AutomationControl	pan_elevation_control ()
AutomationControl	pan_frontback_control ()
AutomationControl	pan_lfe_control ()
AutomationControl	pan_width_control ()
PhaseControl	phase_control ()
PresentationInfo	presentation_info_ptr ()
AutomationControl	rec_enable_control ()
AutomationControl	rec_safe_control ()
AutomationControl	send_enable_controllable (unsigned int)
AutomationControl	send_level_controllable (unsigned int, bool)
std::string	send_name (unsigned int)
AutomationControl	send_pan_azimuth_controllable (unsigned int)
AutomationControl	send_pan_azimuth_enable_controllable (unsigned int)
void	set_presentation_order (unsigned int)
bool	slaved ()
bool	slaved_to (VCA)
SoloControl	solo_control ()
SoloIsolateControl	solo_isolate_control ()
SoloSafeControl	solo_safe_control ()
GainControl	trim_control ()
Cast
Automatable	to_automatable ()
Route	to_route ()
Slavable	to_slavable ()
VCA	to_vca ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:MidiTrackList

C‡: std::list<std::shared_ptr<ARDOUR::MidiTrack> >

Constructor
ℂ	ARDOUR.MidiTrackList ()
Methods
LuaTable	add (LuaTable {MidiTrack})
MidiTrack	back ()
void	clear ()
bool	empty ()
MidiTrack	front ()
LuaIter	iter ()
void	push_back (MidiTrack)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

↠ ARDOUR:MixerScene

C‡: std::shared_ptr< ARDOUR::MixerScene >, std::weak_ptr< ARDOUR::MixerScene >

Base class for objects with saveable and undoable state

Methods
bool	apply ()
bool	apply_to (ControllableSet, AutomationTypeSet)
void	clear ()
bool	empty ()
bool	isnil ()
std::string	name ()
bool	set_name (std::string)
void	snapshot ()

↠ ARDOUR:MonitorControl

C‡: std::shared_ptr< ARDOUR::MonitorControl >, std::weak_ptr< ARDOUR::MonitorControl >

is-a: ARDOUR:SlavableAutomationControl

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
MonitorChoice	monitoring_choice ()

Inherited from ARDOUR:SlavableAutomationControl

Methods
void	add_master (AutomationControl)
void	clear_masters ()
int	get_boolean_masters ()
double	get_masters_value ()
void	remove_master (AutomationControl)
bool	slaved ()
bool	slaved_to (AutomationControl)

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:MonitorProcessor

C‡: std::shared_ptr< ARDOUR::MonitorProcessor >, std::weak_ptr< ARDOUR::MonitorProcessor >

is-a: ARDOUR:Processor

Base class for objects with saveable and undoable state

Methods
Controllable	channel_cut_control (unsigned int)
Controllable	channel_dim_control (unsigned int)
Controllable	channel_polarity_control (unsigned int)
Controllable	channel_solo_control (unsigned int)
bool	cut (unsigned int)
bool	cut_all ()
Controllable	cut_control ()
bool	dim_all ()
Controllable	dim_control ()
float	dim_level ()
Controllable	dim_level_control ()
bool	dimmed (unsigned int)
bool	inverted (unsigned int)
bool	isnil ()
bool	monitor_active ()
bool	mono ()
Controllable	mono_control ()
void	set_cut (unsigned int, bool)
void	set_cut_all (bool)
void	set_dim (unsigned int, bool)
void	set_dim_all (bool)
void	set_mono (bool)
void	set_polarity (unsigned int, bool)
void	set_solo (unsigned int, bool)
Controllable	solo_boost_control ()
float	solo_boost_level ()
bool	soloed (unsigned int)

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:MuteControl

C‡: std::shared_ptr< ARDOUR::MuteControl >, std::weak_ptr< ARDOUR::MuteControl >

is-a: ARDOUR:SlavableAutomationControl

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
MutePoint	mute_points ()
bool	muted ()
bool	muted_by_self ()
void	set_mute_points (MutePoint)

Inherited from ARDOUR:SlavableAutomationControl

Methods
void	add_master (AutomationControl)
void	clear_masters ()
int	get_boolean_masters ()
double	get_masters_value ()
void	remove_master (AutomationControl)
bool	slaved ()
bool	slaved_to (AutomationControl)

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:NotePtrList

C‡: std::list<std::shared_ptr<Evoral::Note<Temporal::Beats> > > >

Constructor
ℂ	ARDOUR.NotePtrList ()
Methods
LuaTable	add (LuaTable {Beats})
NotePtr	back ()
void	clear ()
bool	empty ()
NotePtr	front ()
LuaIter	iter ()
void	push_back (NotePtr)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∅ ARDOUR:OwnedPropertyList

C‡: PBD::OwnedPropertyList

is-a: ARDOUR:PropertyList

Persistent Property List

A variant of PropertyList that does not delete its property list in its destructor. Objects with their own Properties store them in an OwnedPropertyList to avoid having them deleted at the wrong time.

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∁ ARDOUR:PDC

C‡: ARDOUR::Latent

Methods
void	force_zero_latency (bool)
bool	zero_latency ()

↠ ARDOUR:PIControl

C‡: std::shared_ptr< ARDOUR::PluginInsert::PIControl >, std::weak_ptr< ARDOUR::PluginInsert::PIControl >

is-a: ARDOUR:PluginControl

A control that manipulates a plugin parameter (control port).

Methods
bool	isnil ()

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:PannerShell

C‡: std::shared_ptr< ARDOUR::PannerShell >, std::weak_ptr< ARDOUR::PannerShell >

is-a: ARDOUR:SessionObjectPtr

Class to manage panning by instantiating and controlling an appropriate Panner object for a given in/out configuration.

Methods
bool	bypassed ()
bool	isnil ()
void	set_bypassed (bool)

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:ParameterDescriptor

C‡: ARDOUR::ParameterDescriptor

is-a: Evoral:ParameterDescriptor

Descriptor of a parameter or control.

Essentially a union of LADSPA, VST and LV2 info.

Constructor
ℂ	[A RDOUR.ParameterDescri ptor]{.functionname}[ ()]{.functionargs}
Methods
[std::string]{.em}	[midi_note_ name]{.functionname}[ ([unsigned char]{.em}, [bool]{.em}, [bool]{.em}, [bool]{ .em})]{.functionargs}
Data Members
[unsigned int]{.em}	[display_pri ority]{.functionname}
	::: dox higher is more important http://lv 2plug.in/ns/ext/port- props#displayPriority ::
[bool]{.em}	[enumer ation]{.functionname}
[bool]{.em}	[inline _ctrl]{.functionname}
[bool]{.em}	[integer _step]{.functionname}
[std::string]{.em}	[ label]{.functionname}
[float]{.em}	[larg estep]{.functionname}
[std::string]{.em}	[prin t_fmt]{.functionname}
	::: dox format string for pretty printing ::
[float]{.em}	[smal lstep]{.functionname}
[bool]{.em}	[sr_depe ndent]{.functionname}
[float]{.em}	[step]{.functionname}

Inherited from Evoral:ParameterDescriptor

Constructor
ℂ	[E voral.ParameterDescri ptor]{.functionname}[ ()]{.functionargs}
Data Members
[bool]{.em}	[logari thmic]{.functionname}
	::: dox True for log-scale parameters ::
[float]{.em}	[ lower]{.functionname}
	::: dox Minimum value (in Hz, for frequencies) ::
[float]{.em}	[n ormal]{.functionname}
	::: dox Default value ::
[unsigned int]{.em}	[range steps]{.functionname}
	::: dox number of steps, [min,max] (inclusive). <= 1 means continuous. == 2 only min, max. For integer controls this is usually (1 + max - min) ::
[bool]{.em}	[to ggled]{.functionname}
	::: dox True iff parameter is boolean ::
[float]{.em}	[ upper]{.functionname}
	::: dox Maximum value (in Hz, for frequencies) ::

∁ ARDOUR:ParameterList

C‡: std::vector<Evoral::Parameter >

Constructor
ℂ	ARDOUR.ParameterList ()
Methods
Parameter	at (unsigned long)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:PatchChangePtrList

C‡: std::list<std::shared_ptr<Evoral::PatchChange<Temporal::Beats> > > >

Constructor
ℂ	ARDOUR.PatchChangePtrList ()
Methods
LuaTable	add (LuaTable {Beats})
PatchChangePtr	back ()
void	clear ()
bool	empty ()
PatchChangePtr	front ()
LuaIter	iter ()
void	push_back (PatchChangePtr)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

↠ ARDOUR:PeakMeter

C‡: std::shared_ptr< ARDOUR::PeakMeter >, std::weak_ptr< ARDOUR::PeakMeter >

is-a: ARDOUR:Processor

Methods
bool	isnil ()
float	meter_level (unsigned int, MeterType)
MeterType	meter_type ()
void	reset_max ()
void	set_meter_type (MeterType)

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:PhaseControl

C‡: std::shared_ptr< ARDOUR::PhaseControl >, std::weak_ptr< ARDOUR::PhaseControl >

is-a: ARDOUR:AutomationControl

Base class for objects with saveable and undoable state

Methods
[bool]{.em}	[inve rted]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_phase_in vert]{.functionname}[ ([unsigned int]{.em}, [bool]{ .em})]{.functionargs}
	::: dox c : Audio channel index. yn : true to invert phase, otherwise false. ::

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:Playlist

C‡: std::shared_ptr< ARDOUR::Playlist >, std::weak_ptr< ARDOUR::Playlist >

is-a: ARDOUR:SessionObjectPtr

A named object associated with a Session. Objects derived from this class are expected to be destroyed before the session calls drop_references().

Methods
void	add_region (Region, timepos_t, float, bool)
Region	combine (RegionList, Track)
unsigned int	count_regions_at (timepos_t)
Playlist	cut (TimelineRangeList&)
DataType	data_type ()
void	duplicate (Region, timepos_t&, timecnt_t, float)
void	duplicate_range (TimelineRange&, float)
void	duplicate_until (Region, timepos_t&, timecnt_t, timepos_t)
bool	empty ()
Region	find_next_region (timepos_t, RegionPoint, int)
timepos_t	find_next_region_boundary (timepos_t, int)
long	find_next_transient (timepos_t, int)
ID	get_orig_track_id ()
bool	hidden ()
bool	isnil ()
void	lower_region (Region)
void	lower_region_to_bottom (Region)
unsigned int	n_regions ()
void	raise_region (Region)
void	raise_region_to_top (Region)
Region	region_by_id (ID)
RegionListPtr	region_list ()
RegionListPtr	regions_at (timepos_t)
RegionListPtr	regions_touched (timepos_t, timepos_t)
RegionListPtr	regions_with_end_within (Range)
RegionListPtr	regions_with_start_within (Range)
void	remove_region (Region)
bool	set_name (std::string)
bool	shared ()
void	split_region (Region, timepos_t)
Region	top_region_at (timepos_t)
Region	top_unmuted_region_at (timepos_t)
void	uncombine (Region)
bool	used ()
Cast
AudioPlaylist	to_audioplaylist ()
MidiPlaylist	to_midiplaylist ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:PlaylistList

C‡: std::vector<std::shared_ptr<ARDOUR::Playlist> >

Constructor
ℂ	ARDOUR.PlaylistList ()
ℂ	ARDOUR.PlaylistList ()
Methods
LuaTable	add (LuaTable {Playlist})
Playlist	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (Playlist)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

↠ ARDOUR:Plugin

C‡: std::shared_ptr< ARDOUR::Plugin >, std::weak_ptr< ARDOUR::Plugin >

is-a: PBD:StatefulDestructiblePtr

A plugin is an external module (usually 3rd party provided) loaded into Ardour for the purpose of digital signal processing.

This class provides an abstraction for methords provided by all supported plugin standards such as presets, name, parameters etc.

Plugins are not used directly in Ardour but always wrapped by a PluginInsert.

Methods
[float]{.em}	[default_v alue]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[IOPortDesc ription](#ARDOUR:Plug in:IOPortDescription)	[describe_io_ port]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [bool]{.em}, [unsigned int]{ .em})]{.functionargs}
[std::string]{.em}	[get_ docs]{.functionname}[ ()]{.functionargs}
[PluginInfo ](#ARDOUR:PluginInfo)	[get_ info]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_param eter]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
LuaTable*([int]{.em}, ...)	[get_parameter_descri ptor]{.functionname}[ ([unsigned int]{.em}, [Para meterDescriptor&](#AR DOUR:ParameterDescrip tor))]{.functionargs}
[std::string]{.em}	[get_parameter_ docs]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[char*]{.em}	[l abel]{.functionname}[ ()]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[last_pr eset]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Last preset to be requested; the settings may have been changed since; find out with parameter_chang ed_since_last_preset. ::: ::
[bool]{.em}	[load_pr eset]{.functionname}[ ([PresetReco rd](#ARDOUR:PresetRec ord))]{.functionargs}
[char*]{.em}	[m aker]{.functionname}[ ()]{.functionargs}
[char*]{.em}	[ name]{.functionname}[ ()]{.functionargs}
*LuaTable*([unsigned int]{.em}, ...)	[nth_param eter]{.functionname}[ ([unsigned int]{.em}, [bool&]{ .em})]{.functionargs}
[unsigned int]{.em}	[parameter_c ount]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[parameter_is_a udio]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[parameter_is_con trol]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[parameter_is_i nput]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[parameter_is_ou tput]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[std::string]{.em}	[parameter_l abel]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[preset_by_l abel]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[preset_by _uri]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[void]{.em}	[remove_pr eset]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[PresetRecord]( #ARDOUR:PresetRecord)	[save_pr eset]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Create a new plugin-preset from the current state name : label to use for new preset (needs to be unique) ::: result-discussion [Re turns]{.word-returns} PresetRecord with empty URI on failure ::: ::
[std::string]{.em}	[uniqu e_id]{.functionname}[ ()]{.functionargs}
Cast
[LuaP roc](#ARDOUR:LuaProc)	[to_lua proc]{.functionname}[ ()]{.functionargs}

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:Plugin:IOPortDescription

C‡: ARDOUR::Plugin::IOPortDescription

Data Members
unsigned int	group_channel
std::string	group_name
bool	is_sidechain
std::string	name

↠ ARDOUR:PluginControl

C‡: std::shared_ptr< ARDOUR::PlugInsertBase::PluginControl >, std::weak_ptr< ARDOUR::PlugInsertBase::PluginControl >

is-a: ARDOUR:AutomationControl

A control that manipulates a plugin parameter (control port).

Methods
bool	isnil ()

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:PluginInfo

C‡: std::shared_ptr< ARDOUR::PluginInfo >, std::weak_ptr< ARDOUR::PluginInfo >

Constructor
ℵ	ARDOUR.PluginInfo ()
Methods
PresetVector	get_presets (bool)
bool	is_instrument ()
bool	isnil ()
Data Members
std::string	category
std::string	creator
ARDOUR:ChanCount	n_inputs
ARDOUR:ChanCount	n_outputs
std::string	name
std::string	path
ARDOUR.PluginType	_type
std::string	unique_id

∁ ARDOUR:PluginInfoList

C‡: std::list<std::shared_ptr<ARDOUR::PluginInfo> >

Constructor
ℂ	ARDOUR.PluginInfoList ()
Methods
LuaTable	add (LuaTable {PluginInfo})
PluginInfo	back ()
void	clear ()
bool	empty ()
PluginInfo	front ()
LuaIter	iter ()
void	push_back (PluginInfo)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

↠ ARDOUR:PluginInsert

C‡: std::shared_ptr< ARDOUR::PluginInsert >, std::weak_ptr< ARDOUR::PluginInsert >

is-a: ARDOUR:Processor

Methods
void	activate ()
void	clear_stats ()
ReadOnlyControl	control_output (unsigned int)
void	deactivate ()
void	enable (bool)
bool	enabled ()
unsigned int	get_count ()
LuaTable(bool, .…)	get_stats (long&, long&, double&, double&)
bool	has_sidechain ()
ChanMapping	input_map (unsigned int)
bool	is_channelstrip ()
bool	is_instrument ()
bool	isnil ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
ChanMapping	output_map (unsigned int)
Plugin	plugin (unsigned int)
bool	reset_parameters_to_default ()
void	set_input_map (unsigned int, ChanMapping)
void	set_output_map (unsigned int, ChanMapping)
void	set_thru_map (ChanMapping)
IO	sidechain_input ()
long	signal_latency ()
bool	strict_io_configured ()
ChanMapping	thru_map ()
PluginType	_type ()
bool	write_immediate_event (EventType, unsigned long, unsigned char*)

Inherited from ARDOUR:Processor

Methods
bool	active ()
long	capture_offset ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:PluginPropertyControl

C‡: std::shared_ptr< ARDOUR::PlugInsertBase::PluginPropertyControl >, std::weak_ptr< ARDOUR::PlugInsertBase::PluginPropertyControl >

is-a: ARDOUR:AutomationControl

A control that manipulates a plugin property (message).

Methods
bool	isnil ()

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

ℕ ARDOUR.PluginType

Methods
std::string	name (PluginType, bool)

↠ ARDOUR:PolarityProcessor

C‡: std::shared_ptr< ARDOUR::PolarityProcessor >, std::weak_ptr< ARDOUR::PolarityProcessor >

is-a: ARDOUR:Processor

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:Port

C‡: std::shared_ptr< ARDOUR::Port >, std::weak_ptr< ARDOUR::Port >

Methods
[int]{.em}	[con nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[conne cted]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this port is connected to anything ::: ::
[bool]{.em}	[connecte d_to]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox o : Port name ::: result-discussion [Re turns]{.word-returns} true if this port is connected to o, otherwise false. ::: ::
[int]{.em}	[discon nect]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[disconnect _all]{.functionname}[ ()]{.functionargs}
[PortFlag s](#ARDOUR.PortFlags)	[f lags]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} flags ::: ::
*LuaTable*(...)	[ge t_connected_latency_r ange]{.functionname}[ ([LatencyRange&](# ARDOUR:LatencyRange), [bool]{ .em})]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port short name ::: ::
[bool]{.em}	[physically_conne cted]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[pretty_ name]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Port human readable name ::: ::
[LatencyRange]( #ARDOUR:LatencyRange)	[private_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[LatencyRange]( #ARDOUR:LatencyRange)	[public_latency_r ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[receives_i nput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port receives input, otherwise false ::: ::
[bool]{.em}	[sends_ou tput]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if this Port sends output, otherwise false ::: ::
Cast
[AsyncMIDIPort](# ARDOUR:AsyncMIDIPort)	[to_asyncmidi port]{.functionname}[ ()]{.functionargs}
[AudioPor t](#ARDOUR:AudioPort)	[to_audio port]{.functionname}[ ()]{.functionargs}
[MidiPo rt](#ARDOUR:MidiPort)	[to_midi port]{.functionname}[ ()]{.functionargs}

∅ ARDOUR:PortEngine

C‡: ARDOUR::PortEngine

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∁ ARDOUR:PortList

C‡: std::list<std::shared_ptr<ARDOUR::Port> >

Constructor
ℂ	ARDOUR.PortList ()
Methods
Port	back ()
bool	empty ()
Port	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:PortManager

C‡: ARDOUR::PortManager

Methods
[int]{.em}	[con nect]{.functionname}[ ([std::string]{.em}, [std::string]{ .em})]{.functionargs}
[bool]{.em}	[conne cted]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[discon nect]{.functionname}[ ([std::string]{.em}, [std::string]{ .em})]{.functionargs}
[int]{.em}	[disconnect_ port]{.functionname}[ ([Port](#ARDOUR:P ort))]{.functionargs}
LuaTable*([int]{.em}, ...)	[get_backend_p orts]{.functionname}[ ([std::string]{.em}, [DataTyp e](#ARDOUR:DataType), [PortFlags ](#ARDOUR.PortFlags), [String Vector&](#C:StringVec tor))]{.functionargs}
LuaTable*([int]{.em}, ...)	[get_connect ions]{.functionname}[ ([std::string]{.em}, [StringVecto r&](#C:StringVector), [bool]{ .em})]{.functionargs}
[void]{.em}	[get_physical_in puts]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [StringVecto r&](#C:StringVector), [MidiPortFlags](#A RDOUR.MidiPortFlags), [MidiPortFlag s](#ARDOUR.MidiPortFl ags))]{.functionargs}
[void]{.em}	[get_physical_out puts]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [StringVecto r&](#C:StringVector), [MidiPortFlags](#A RDOUR.MidiPortFlags), [MidiPortFlag s](#ARDOUR.MidiPortFl ags))]{.functionargs}
[Port](#ARDOUR:Port)	[get_port_by_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox name : Full or short name of port ::: result-discussion [Re turns]{.word-returns} Corresponding Port or 0. ::: ::
LuaTable*([int]{.em}, ...)	[get_p orts]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [Por tList&](#ARDOUR:PortL ist))]{.functionargs}
[std::string]{.em}	[get_pretty_name_by_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_physical_in puts]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_physical_out puts]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[physically_conne cted]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[PortEngine ](#ARDOUR:PortEngine)	[port_en gine]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[port_is_phys ical]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[void]{.em}	[reset_input_me ters]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:PortSet

C‡: std::shared_ptr< ARDOUR::PortSet >, std::weak_ptr< ARDOUR::PortSet >

An ordered list of Ports, possibly of various types.

This allows access to all the ports as a list, ignoring type, or accessing the nth port of a given type. Note that port(n) and nth_audio_port(n) may NOT return the same port.

Each port is held twice; once in a per-type vector of vectors (_ports) and once in a vector of all port (_all_ports). This is to speed up the fairly common case of iterating over all ports.

Methods
[void]{.em}	[add]{.functionname}[ ([Port](#ARDOUR:P ort))]{.functionargs}
[void]{.em}	[c lear]{.functionname}[ ()]{.functionargs}
	::: dox Remove all ports from the PortSet. Ports are not deregistered with the engine, it's the caller's responsibility to not leak here! ::
[bool]{.em}	[cont ains]{.functionname}[ ([Port](#ARDOUR:P ort))]{.functionargs}
[bool]{.em}	[e mpty]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[unsigned long]{.em}	[num_p orts]{.functionname}[ ([Da taType](#ARDOUR:DataT ype))]{.functionargs}
[Port](#ARDOUR:Port)	[ port]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [unsigned long]{ .em})]{.functionargs}
[bool]{.em}	[re move]{.functionname}[ ([Port](#ARDOUR:P ort))]{.functionargs}

∁ ARDOUR:PresentationInfo

C‡: ARDOUR::PresentationInfo

is-a: PBD:Stateful

Base class for objects with saveable and undoable state

Methods
unsigned int	color ()
Flag	flags ()
unsigned int	order ()
void	set_color (unsigned int)
bool	special (bool)

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:PresetRecord

C‡: ARDOUR::Plugin::PresetRecord

Constructor
ℂ	ARDOUR.PresetRecord ()
Data Members
std::string	label
std::string	uri
bool	user
bool	valid

∁ ARDOUR:PresetVector

C‡: std::vector<ARDOUR::Plugin::PresetRecord >

Constructor
ℂ	ARDOUR.PresetVector ()
ℂ	ARDOUR.PresetVector ()
Methods
LuaTable	add (LuaTable {PresetRecord})
PresetRecord	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (PresetRecord)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

↠ ARDOUR:Processor

C‡: std::shared_ptr< ARDOUR::Processor >, std::weak_ptr< ARDOUR::Processor >

is-a: ARDOUR:SessionObjectPtr

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
bool	isnil ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:ProcessorList

C‡: std::list<std::shared_ptr<ARDOUR::Processor> >

Constructor
ℂ	ARDOUR.ProcessorList ()
Methods
LuaTable	add (LuaTable {Processor})
Processor	back ()
void	clear ()
bool	empty ()
Processor	front ()
LuaIter	iter ()
void	push_back (Processor)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ARDOUR:ProcessorVector

C‡: std::vector<std::shared_ptr<ARDOUR::Processor> >

Constructor
ℂ	ARDOUR.ProcessorVector ()
ℂ	ARDOUR.ProcessorVector ()
Methods
LuaTable	add (LuaTable {Processor})
Processor	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (Processor)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∅ ARDOUR:Properties:BoolProperty

C‡: PBD::PropertyDescriptor<bool>

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∅ ARDOUR:Properties:FloatProperty

C‡: PBD::PropertyDescriptor<float>

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∅ ARDOUR:Properties:SamplePosProperty

C‡: PBD::PropertyDescriptor<long>

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∅ ARDOUR:Properties:StringProperty

C‡: PBD::PropertyDescriptor<std::string >

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∅ ARDOUR:Properties:TimeCntProperty

C‡: PBD::PropertyDescriptor<Temporal::timecnt_t>

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∅ ARDOUR:Properties:TimePosProperty

C‡: PBD::PropertyDescriptor<Temporal::timepos_t>

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∁ ARDOUR:PropertyChange

C‡: PBD::PropertyChange

A list of IDs of Properties that have changed in some situation or other

Methods
bool	containsBool (BoolProperty)
bool	containsFloat (FloatProperty)
bool	containsSamplePos (SamplePosProperty)
bool	containsString (StringProperty)
bool	containsTimeCnt (TimeCntProperty)
bool	containsTimePos (TimePosProperty)

∅ ARDOUR:PropertyList

C‡: PBD::PropertyList

A list of properties, mapped using their ID

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∁ ARDOUR:RCConfiguration

C‡: ARDOUR::RCConfiguration

is-a: PBD:Configuration

Base class for objects with saveable and undoable state

Methods
[AFLPosition] (#ARDOUR.AFLPosition)	[get_afl_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_all_ safe]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_ allow_special_bus_rem oval]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[g et_ask_replace_instru ment]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_ask_setup_instru ment]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_aud io_capture_buffer_sec onds]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_audi o_playback_buffer_sec onds]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[g et_auditioner_output_ left]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[std::string]{.em}	[ge t_auditioner_output_r ight]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_auto_analyse_a udio]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_aut o_connect_standard_bu sses]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_auto_enable_surf aces]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get _auto_input_does_talk back]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_auto _return_after_rewind_ ffwd]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[A utoReturnTarget](#ARD OUR.AutoReturnTarget)	[ge t_auto_return_target_ list]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_a utomation_follows_reg ions]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_ automation_interval_m secs]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[double]{.em}	[get_a utomation_thinning_fa ctor]{.functionname}[ ()]{.functionargs}
[BufferingPreset](#AR DOUR.BufferingPreset)	[get_buffering_pr eset]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_click_emphasis_s ound]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_click_ gain]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_click_record_ only]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_click_s ound]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_clic king]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_clip_library _dir]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_ conceal_lv1_if_lv2_ex ists]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_co nceal_vst2_if_vst3_ex ists]{.functionname}[ ()]{.functionargs}
[int]{.em}	[get_cpu_dma_lat ency]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_create_xrun_ma rker]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[TimeDomain]( #Temporal.TimeDomain)	[get_defau lt_automation_time_do main]{.functionname}[ ()]{.functionargs}
[FadeShap e](#ARDOUR.FadeShape)	[get_default_fade_s hape]{.functionname}[ ()]{.functionargs}
[AnyT ime](#ARDOUR:AnyTime)	[get_default_quantiza tion]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_d efault_session_parent _dir]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_d efault_trigger_input_ port]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[g et_demo_session_index _url]{.functionname}[ ()]{.functionargs}
[DenormalModel](# ARDOUR.DenormalModel)	[get_denormal_m odel]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_denormal_protec tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_d isable_disarm_during_ roll]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_ discover_plugins_on_s tart]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_di sk_choice_space_thres hold]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_donate _url]{.functionname}[ ()]{.functionargs}
[EditMo de](#ARDOUR.EditMode)	[get_edit_ mode]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_exclusive_ solo]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_export_pre roll]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get _export_silence_thres hold]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_feedback_interva l_ms]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ge t_first_midi_bank_is_ zero]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[g et_group_override_inv erts]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_hide_dummy_bac kend]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_hiding_ groups_deactivates_gr oups]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[int]{.em}	[get_history_d epth]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_imp licit_selection_op_gr oups]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[int]{.em}	[g et_initial_program_ch ange]{.functionname}[ ()]{.functionargs}
[Aut oConnectOption](#ARDO UR.AutoConnectOption)	[get_input_auto_con nect]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[int]{.em}	[ge t_inter_scene_gap_sam ples]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_interview_edi ting]{.functionname}[ ()]{.functionargs}
[int]{.em}	[get_io_thread_c ount]{.functionname}[ ()]{.functionargs}
[int]{.em}	[get_io_thread_po licy]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ get_latched_record_en able]{.functionname}[ ()]{.functionargs}
[LayerModel ](#ARDOUR.LayerModel)	[get_layer_m odel]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_limit_n_automata bles]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_l ink_send_and_route_pa nner]{.functionname}[ ()]{.functionargs}
[ListenPosition](#A RDOUR.ListenPosition)	[get_listen_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_locate_to_pgm_ch ange]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_loca te_while_waiting_for_ sync]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[LoopFadeChoice](#A RDOUR.LoopFadeChoice)	[get_loop_fade_ch oice]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_loop_is_ mode]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[std::string]{.em}	[get_ltc_output_ port]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_ltc_output_vo lume]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ get_ltc_send_continuo usly]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_mark_at_pgm_ch ange]{.functionname}[ ()]{.functionargs}
[MarkerLoc atePriority](#ARDOUR. MarkerLocatePriority)	[g et_marker_locate_prio rity]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[float]{.em}	[ge t_max_audio_clip_dura tion]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_max_ gain]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_max_midi_clip_ size]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_max_recent_sess ions]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_max_recent_templ ates]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_max_tail_sam ples]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_max_transport_s peed]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_meter_fal loff]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[MeterTyp e](#ARDOUR.MeterType)	[get_meter_type _bus]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[MeterTyp e](#ARDOUR.MeterType)	[get_meter_type_ma ster]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[MeterTyp e](#ARDOUR.MeterType)	[get_meter_type_t rack]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[std::string]{.em}	[ge t_midi_audition_synth _uri]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_midi_c hase]{.functionname}[ ()]{.functionargs}
[double]{.em}	[ get_midi_clock_resolu tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ get_midi_clock_sets_t empo]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_midi_feed back]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_mid i_input_follows_selec tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ge t_midi_panic_when_loo ping]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_ midi_track_buffer_sec onds]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[ge t_minimum_disk_read_b ytes]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get _minimum_disk_write_b ytes]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_mmc_con trol]{.functionname}[ ()]{.functionargs}
[FastWindOp ](#ARDOUR.FastWindOp)	[get_mmc_fast_win d_op]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[int]{.em}	[ get_mmc_receive_devic e_id]{.functionname}[ ()]{.functionargs}
[int]{.em}	[get_mmc_send_devic e_id]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_mon itor_bus_preferred_bu ndle]{.functionname}[ ()]{.functionargs}
[MonitorModel]( #ARDOUR.MonitorModel)	[get_monitoring_m odel]{.functionname}[ ()]{.functionargs}
[int]{.em}	[g et_mtc_qf_speed_toler ance]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_ mute_affects_control_ outs]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[g et_mute_affects_main_ outs]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ge t_mute_affects_post_f ader]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[g et_mute_affects_pre_f ader]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_mu te_affects_surround_s ends]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_new_plugins_ac tive]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_osc_ port]{.functionname}[ ()]{.functionargs}
[Aut oConnectOption](#ARDO UR.AutoConnectOption)	[get_output_auto_con nect]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[unsigned int]{.em}	[get_period ic_safety_backup_inte rval]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[ge t_periodic_safety_bac kups]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[PFLPosition] (#ARDOUR.PFLPosition)	[get_pfl_posi tion]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_pingback _url]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_plugin_cache_ver sion]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_plugin_path_l xvst]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_plugin_path _vst]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_plugin_path_ vst3]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_plugin_scan_tim eout]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_pl ugins_stop_with_trans port]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[unsigned int]{.em}	[g et_port_resampler_qua lity]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[float]{.em}	[g et_ppqn_factor_for_ex port]{.functionname}[ ()]{.functionargs}
[TimeDomain]( #Temporal.TimeDomain)	[ get_preferred_time_do main]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[float]{.em}	[get_preroll_sec onds]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[int]{.em}	[get_processor_u sage]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_quieten_at_s peed]{.functionname}[ ()]{.functionargs}
[long]{.em}	[g et_range_location_min imum]{.functionname}[ ()]{.functionargs}
[RangeSelectionAft erSplit](#ARDOUR.Rang eSelectionAfterSplit)	[get_ra nge_selection_after_s plit]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_re cording_resets_xrun_c ount]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[std::string]{.em}	[get_reference_manual _url]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_region_bounda ries_from_onscreen_tr acks]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_region_bounda ries_from_selected_tr acks]{.functionname}[ ()]{.functionargs}
[Reg ionEquivalence](#ARDO UR.RegionEquivalence)	[get_region_equival ence]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[RegionSelectionAfte rSplit](#ARDOUR.Regio nSelectionAfterSplit)	[get_reg ion_selection_after_s plit]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_replicat e_missing_region_chan nels]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_re set_default_speed_on_ stop]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[std::string]{.em}	[get_resource_index _url]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_res tore_hardware_connect ions]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_re wind_ffwd_like_tape_d ecks]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[RippleMode ](#ARDOUR.RippleMode)	[get_ripple_ mode]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_roll_will_ loop]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_run_all _transport_masters_al ways]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_sample_lib_ path]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_save_his tory]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[int]{.em}	[get_saved_history_d epth]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_send _ltc]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_send_midi_c lock]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_send _mmc]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_send _mtc]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_setup_sidec hain]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_show_solo_m utes]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get _show_video_server_di alog]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_sh ow_vst3_micro_edit_in line]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_shuttle_max_s peed]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[float]{.em}	[get_shuttle_speed_fa ctor]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[float]{.em}	[ge t_shuttle_speed_thres hold]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[ShuttleUnits]( #ARDOUR.ShuttleUnits)	[get_shuttle_u nits]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_skip_play back]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_solo_ control_is_listen_con trol]{.functionname}[ ()]{.functionargs}
[float]{.em}	[get_solo_mute_ gain]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_solo_mute_over ride]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_stop_at_session _end]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_stop_on_ grid]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[g et_stop_recording_on_ xrun]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_stric t_io]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[float]{.em}	[get_tail_duration _sec]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get _timecode_sync_frame_ rate]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_trace_midi_i nput]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_trace_midi_ou tput]{.functionname}[ ()]{.functionargs}
[TracksAut oNamingRule](#ARDOUR. TracksAutoNamingRule)	[get_tracks_auto_na ming]{.functionname}[ ()]{.functionargs}
[float]{.em}	[ get_transient_sensiti vity]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ get_transport_masters _just_roll_when_sync_ lost]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_try_autostart_en gine]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[std::string]{.em}	[get_tutorial_manual _url]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_updates _url]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_audio_u nits]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_click_emph asis]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_l xvst]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_ma cvst]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_master_vo lume]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_monitor _bus]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use _osc]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_plugin_own _gui]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_ vst3]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_use_windows _vst]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_verbose_plugin_ scan]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_v erify_remove_last_cap ture]{.functionname}[ ()]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[get_video_advanced_s etup]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_video_server_doc root]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_video_server _url]{.functionname}[ ()]{.functionargs}
[VST3KnobMode]( #ARDOUR.VST3KnobMode)	[get_vst3_knob_ mode]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_work_around_ jack_no_copy_optimiza tion]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[get_xjadeo_bi nary]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[set_afl_posi tion]{.functionname}[ ([AFLPosit ion](#ARDOUR.AFLPosit ion))]{.functionargs}
[bool]{.em}	[set_all_ safe]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_ allow_special_bus_rem oval]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[s et_ask_replace_instru ment]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_ask_setup_instru ment]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_aud io_capture_buffer_sec onds]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_audi o_playback_buffer_sec onds]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[s et_auditioner_output_ left]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[se t_auditioner_output_r ight]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_auto_analyse_a udio]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_aut o_connect_standard_bu sses]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_auto_enable_surf aces]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set _auto_input_does_talk back]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_auto _return_after_rewind_ ffwd]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[se t_auto_return_target_ list]{.functionname}[ ([AutoReturnTarget]( #ARDOUR.AutoReturnTar get))]{.functionargs}
[bool]{.em}	[set_a utomation_follows_reg ions]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_ automation_interval_m secs]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_a utomation_thinning_fa ctor]{.functionname}[ ([double]{ .em})]{.functionargs}
[bool]{.em}	[set_buffering_pr eset]{.functionname}[ ([BufferingPreset] (#ARDOUR.BufferingPre set))]{.functionargs}
[bool]{.em}	[set_click_emphasis_s ound]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_click_ gain]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_click_record_ only]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_click_s ound]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_clic king]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_clip_library _dir]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_ conceal_lv1_if_lv2_ex ists]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_co nceal_vst2_if_vst3_ex ists]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_cpu_dma_lat ency]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_create_xrun_ma rker]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_defau lt_automation_time_do main]{.functionname}[ ([TimeDoma in](#Temporal.TimeDom ain))]{.functionargs}
[bool]{.em}	[set_default_fade_s hape]{.functionname}[ ([Fade Shape](#ARDOUR.FadeSh ape))]{.functionargs}
[bool]{.em}	[set_default_quantiza tion]{.functionname}[ ([ AnyTime](#ARDOUR:AnyT ime))]{.functionargs}
[bool]{.em}	[set_d efault_session_parent _dir]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_d efault_trigger_input_ port]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[s et_demo_session_index _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_denormal_m odel]{.functionname}[ ([DenormalMode l](#ARDOUR.DenormalMo del))]{.functionargs}
[bool]{.em}	[set_denormal_protec tion]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_d isable_disarm_during_ roll]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_ discover_plugins_on_s tart]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_di sk_choice_space_thres hold]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_donate _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_edit_ mode]{.functionname}[ ([Ed itMode](#ARDOUR.EditM ode))]{.functionargs}
[bool]{.em}	[set_exclusive_ solo]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_export_pre roll]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set _export_silence_thres hold]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_feedback_interva l_ms]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[se t_first_midi_bank_is_ zero]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[s et_group_override_inv erts]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_hide_dummy_bac kend]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_hiding_ groups_deactivates_gr oups]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_history_d epth]{.functionname}[ ([int]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_imp licit_selection_op_gr oups]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[s et_initial_program_ch ange]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_input_auto_con nect]{.functionname}[ ( [AutoConnectOption](# ARDOUR.AutoConnectOpt ion))]{.functionargs}
[bool]{.em}	[se t_inter_scene_gap_sam ples]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_interview_edi ting]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_io_thread_c ount]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_io_thread_po licy]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[ set_latched_record_en able]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_layer_m odel]{.functionname}[ ([LayerM odel](#ARDOUR.LayerMo del))]{.functionargs}
[bool]{.em}	[set_limit_n_automata bles]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_l ink_send_and_route_pa nner]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_listen_posi tion]{.functionname}[ ([ListenPosition ](#ARDOUR.ListenPosit ion))]{.functionargs}
[bool]{.em}	[set_locate_to_pgm_ch ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_loca te_while_waiting_for_ sync]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_loop_fade_ch oice]{.functionname}[ ([LoopFadeChoice ](#ARDOUR.LoopFadeCho ice))]{.functionargs}
[bool]{.em}	[set_loop_is_ mode]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_ltc_output_ port]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_ltc_output_vo lume]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[ set_ltc_send_continuo usly]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_mark_at_pgm_ch ange]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[s et_marker_locate_prio rity]{.functionname}[ ([Marke rLocatePriority](#ARD OUR.MarkerLocatePrior ity))]{.functionargs}
[bool]{.em}	[se t_max_audio_clip_dura tion]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_max_ gain]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_max_midi_clip_ size]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_max_recent_sess ions]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_max_recent_templ ates]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_max_tail_sam ples]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_max_transport_s peed]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_meter_fal loff]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_meter_type _bus]{.functionname}[ ([Mete rType](#ARDOUR.MeterT ype))]{.functionargs}
[bool]{.em}	[set_meter_type_ma ster]{.functionname}[ ([Mete rType](#ARDOUR.MeterT ype))]{.functionargs}
[bool]{.em}	[set_meter_type_t rack]{.functionname}[ ([Mete rType](#ARDOUR.MeterT ype))]{.functionargs}
[bool]{.em}	[se t_midi_audition_synth _uri]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_midi_c hase]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[ set_midi_clock_resolu tion]{.functionname}[ ([double]{ .em})]{.functionargs}
[bool]{.em}	[ set_midi_clock_sets_t empo]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_midi_feed back]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_mid i_input_follows_selec tion]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[se t_midi_panic_when_loo ping]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_ midi_track_buffer_sec onds]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[se t_minimum_disk_read_b ytes]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set _minimum_disk_write_b ytes]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_mmc_con trol]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_mmc_fast_win d_op]{.functionname}[ ([FastWi ndOp](#ARDOUR.FastWin dOp))]{.functionargs}
[bool]{.em}	[ set_mmc_receive_devic e_id]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_mmc_send_devic e_id]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_mon itor_bus_preferred_bu ndle]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_monitoring_m odel]{.functionname}[ ([MonitorMod el](#ARDOUR.MonitorMo del))]{.functionargs}
[bool]{.em}	[s et_mtc_qf_speed_toler ance]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_ mute_affects_control_ outs]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[s et_mute_affects_main_ outs]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[se t_mute_affects_post_f ader]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[s et_mute_affects_pre_f ader]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_mu te_affects_surround_s ends]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_new_plugins_ac tive]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_osc_ port]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_output_auto_con nect]{.functionname}[ ( [AutoConnectOption](# ARDOUR.AutoConnectOpt ion))]{.functionargs}
[bool]{.em}	[set_period ic_safety_backup_inte rval]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[se t_periodic_safety_bac kups]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_pfl_posi tion]{.functionname}[ ([PFLPosit ion](#ARDOUR.PFLPosit ion))]{.functionargs}
[bool]{.em}	[set_pingback _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_plugin_cache_ver sion]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_plugin_path_l xvst]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_plugin_path _vst]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_plugin_path_ vst3]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_plugin_scan_tim eout]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[bool]{.em}	[set_pl ugins_stop_with_trans port]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[s et_port_resampler_qua lity]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[s et_ppqn_factor_for_ex port]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[ set_preferred_time_do main]{.functionname}[ ([TimeDoma in](#Temporal.TimeDom ain))]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_preroll_sec onds]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_processor_u sage]{.functionname}[ ([int]{ .em})]{.functionargs}
[bool]{.em}	[set_quieten_at_s peed]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[s et_range_location_min imum]{.functionname}[ ([long]{ .em})]{.functionargs}
[bool]{.em}	[set_ra nge_selection_after_s plit]{.functionname}[ ([RangeSelectio nAfterSplit](#ARDOUR. RangeSelectionAfterSp lit))]{.functionargs}
[bool]{.em}	[set_re cording_resets_xrun_c ount]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_reference_manual _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_region_bounda ries_from_onscreen_tr acks]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_region_bounda ries_from_selected_tr acks]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_region_equival ence]{.functionname}[ ( [RegionEquivalence](# ARDOUR.RegionEquivale nce))]{.functionargs}
[bool]{.em}	[set_reg ion_selection_after_s plit]{.functionname}[ ([RegionSelection AfterSplit](#ARDOUR.R egionSelectionAfterSp lit))]{.functionargs}
[bool]{.em}	[set_replicat e_missing_region_chan nels]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_re set_default_speed_on_ stop]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_resource_index _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_res tore_hardware_connect ions]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_re wind_ffwd_like_tape_d ecks]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_ripple_ mode]{.functionname}[ ([Ripple Mode](#ARDOUR.RippleM ode))]{.functionargs}
[bool]{.em}	[set_roll_will_ loop]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_run_all _transport_masters_al ways]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_sample_lib_ path]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_save_his tory]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_saved_history_d epth]{.functionname}[ ([int]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_send _ltc]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_send_midi_c lock]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_send _mmc]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_send _mtc]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_setup_sidec hain]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_show_solo_m utes]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set _show_video_server_di alog]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_sh ow_vst3_micro_edit_in line]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_shuttle_max_s peed]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_shuttle_speed_fa ctor]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[se t_shuttle_speed_thres hold]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_shuttle_u nits]{.functionname}[ ([ShuttleUni ts](#ARDOUR.ShuttleUn its))]{.functionargs}
[bool]{.em}	[set_skip_play back]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_solo_ control_is_listen_con trol]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_solo_mute_ gain]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set_solo_mute_over ride]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_stop_at_session _end]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_stop_on_ grid]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[s et_stop_recording_on_ xrun]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_stric t_io]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_tail_duration _sec]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[set _timecode_sync_frame_ rate]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_trace_midi_i nput]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_trace_midi_ou tput]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_tracks_auto_na ming]{.functionname}[ ([Track sAutoNamingRule](#ARD OUR.TracksAutoNamingR ule))]{.functionargs}
[bool]{.em}	[ set_transient_sensiti vity]{.functionname}[ ([float]{ .em})]{.functionargs}
[bool]{.em}	[ set_transport_masters _just_roll_when_sync_ lost]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_try_autostart_en gine]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_tutorial_manual _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_updates _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_use_audio_u nits]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_click_emph asis]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_l xvst]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_ma cvst]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_master_vo lume]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_monitor _bus]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use _osc]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_plugin_own _gui]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_ vst3]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_use_windows _vst]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_verbose_plugin_ scan]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_v erify_remove_last_cap ture]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox if true, we call Processor::flush() on all processors when the transport is stopped. Note that processors are still run when the transport is not moving. ::
[bool]{.em}	[set_video_advanced_s etup]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_video_server_doc root]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_video_server _url]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_vst3_knob_ mode]{.functionname}[ ([VST3KnobMo de](#ARDOUR.VST3KnobM ode))]{.functionargs}
[bool]{.em}	[set_work_around_ jack_no_copy_optimiza tion]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_xjadeo_bi nary]{.functionname}[ ([std::string]{ .em})]{.functionargs}
Properties
[ARDOUR.AFLPosition] (#ARDOUR.AFLPosition)	[afl_pos ition]{.functionname}
[bool]{.em}	[all _safe]{.functionname}
[bool]{.em}	[allow_special_bus_re moval]{.functionname}
[bool]{.em}	[ask_replace_instr ument]{.functionname}
[bool]{.em}	[ask_setup_instr ument]{.functionname}
[float]{.em}	[au dio_capture_buffer_se conds]{.functionname}
[float]{.em}	[aud io_playback_buffer_se conds]{.functionname}
[std::string]{.em}	[auditioner_output _left]{.functionname}
[std::string]{.em}	[auditioner_output_ right]{.functionname}
[bool]{.em}	[auto_analyse_ audio]{.functionname}
[bool]{.em}	[au to_connect_standard_b usses]{.functionname}
[bool]{.em}	[auto_enable_sur faces]{.functionname}
[bool]{.em}	[auto_input_does_tal kback]{.functionname}
[bool]{.em}	[aut o_return_after_rewind _ffwd]{.functionname}
[ARDOUR.A utoReturnTarget](#ARD OUR.AutoReturnTarget)	[auto_return_target _list]{.functionname}
[bool]{.em}	[ automation_follows_re gions]{.functionname}
[float]{.em}	[automation_interval_ msecs]{.functionname}
[double]{.em}	[ automation_thinning_f actor]{.functionname}
[ARDOUR .BufferingPreset](#AR DOUR.BufferingPreset)	[buffering_p reset]{.functionname}
[std::string]{.em}	[click_emphasis_ sound]{.functionname}
[float]{.em}	[click _gain]{.functionname}
[bool]{.em}	[click_record _only]{.functionname}
[std::string]{.em}	[click_ sound]{.functionname}
[bool]{.em}	[cli cking]{.functionname}
[std::string]{.em}	[clip_librar y_dir]{.functionname}
[bool]{.em}	[conceal_lv1_if_lv2_e xists]{.functionname}
[bool]{.em}	[c onceal_vst2_if_vst3_e xists]{.functionname}
[int]{.em}	[cpu_dma_la tency]{.functionname}
[bool]{.em}	[create_xrun_m arker]{.functionname}
[ Temporal.TimeDomain]( #Temporal.TimeDomain)	[defa ult_automation_time_d omain]{.functionname}
[ARDOUR.FadeShap e](#ARDOUR.FadeShape)	[default_fade_ shape]{.functionname}
[ARDOUR:AnyT ime](#ARDOUR:AnyTime)	[default_quantiz ation]{.functionname}
[std::string]{.em}	[ default_session_paren t_dir]{.functionname}
[std::string]{.em}	[ default_trigger_input _port]{.functionname}
[std::string]{.em}	[demo_session_inde x_url]{.functionname}
[AR DOUR.DenormalModel](# ARDOUR.DenormalModel)	[denormal_ model]{.functionname}
[bool]{.em}	[denormal_prote ction]{.functionname}
[bool]{.em}	[ disable_disarm_during _roll]{.functionname}
[bool]{.em}	[discover_plugins_on_ start]{.functionname}
[unsigned int]{.em}	[d isk_choice_space_thre shold]{.functionname}
[std::string]{.em}	[donat e_url]{.functionname}
[ARDOUR.EditMo de](#ARDOUR.EditMode)	[edit _mode]{.functionname}
[bool]{.em}	[exclusive _solo]{.functionname}
[float]{.em}	[export_pr eroll]{.functionname}
[float]{.em}	[export_silence_thre shold]{.functionname}
[unsigned int]{.em}	[feedback_interv al_ms]{.functionname}
[bool]{.em}	[first_midi_bank_is _zero]{.functionname}
[bool]{.em}	[group_override_in verts]{.functionname}
[bool]{.em}	[hide_dummy_ba ckend]{.functionname}
[bool]{.em}	[hiding _groups_deactivates_g roups]{.functionname}
[int]{.em}	[history_ depth]{.functionname}
[bool]{.em}	[im plicit_selection_op_g roups]{.functionname}
[int]{.em}	[initial_program_c hange]{.functionname}
[ARDOUR.Aut oConnectOption](#ARDO UR.AutoConnectOption)	[input_auto_co nnect]{.functionname}
[int]{.em}	[inter_scene_gap_sa mples]{.functionname}
[bool]{.em}	[interview_ed iting]{.functionname}
[int]{.em}	[io_thread_ count]{.functionname}
[int]{.em}	[io_thread_p olicy]{.functionname}
[bool]{.em}	[latched_record_e nable]{.functionname}
[ARDOUR.LayerModel ](#ARDOUR.LayerModel)	[layer_ model]{.functionname}
[unsigned int]{.em}	[limit_n_automat ables]{.functionname}
[bool]{.em}	[ link_send_and_route_p anner]{.functionname}
[ARDO UR.ListenPosition](#A RDOUR.ListenPosition)	[listen_pos ition]{.functionname}
[bool]{.em}	[locate_to_pgm_c hange]{.functionname}
[bool]{.em}	[loc ate_while_waiting_for _sync]{.functionname}
[ARDO UR.LoopFadeChoice](#A RDOUR.LoopFadeChoice)	[loop_fade_c hoice]{.functionname}
[bool]{.em}	[loop_is _mode]{.functionname}
[std::string]{.em}	[ltc_output _port]{.functionname}
[float]{.em}	[ltc_output_v olume]{.functionname}
[bool]{.em}	[ltc_send_continu ously]{.functionname}
[bool]{.em}	[mark_at_pgm_c hange]{.functionname}
[ARDOUR.MarkerLoc atePriority](#ARDOUR. MarkerLocatePriority)	[marker_locate_pri ority]{.functionname}
[float]{.em}	[max_audio_clip_dur ation]{.functionname}
[float]{.em}	[max _gain]{.functionname}
[float]{.em}	[max_midi_clip _size]{.functionname}
[unsigned int]{.em}	[max_recent_ses sions]{.functionname}
[unsigned int]{.em}	[max_recent_temp lates]{.functionname}
[unsigned int]{.em}	[max_tail_sa mples]{.functionname}
[float]{.em}	[max_transport_ speed]{.functionname}
[float]{.em}	[meter_fa lloff]{.functionname}
[ARDOUR.MeterTyp e](#ARDOUR.MeterType)	[meter_typ e_bus]{.functionname}
[ARDOUR.MeterTyp e](#ARDOUR.MeterType)	[meter_type_m aster]{.functionname}
[ARDOUR.MeterTyp e](#ARDOUR.MeterType)	[meter_type_ track]{.functionname}
[std::string]{.em}	[midi_audition_synt h_uri]{.functionname}
[bool]{.em}	[midi_ chase]{.functionname}
[double]{.em}	[midi_clock_resol ution]{.functionname}
[bool]{.em}	[midi_clock_sets_ tempo]{.functionname}
[bool]{.em}	[midi_fee dback]{.functionname}
[bool]{.em}	[mi di_input_follows_sele ction]{.functionname}
[bool]{.em}	[midi_panic_when_lo oping]{.functionname}
[float]{.em}	[midi_track_buffer_se conds]{.functionname}
[unsigned int]{.em}	[minimum_disk_read_ bytes]{.functionname}
[unsigned int]{.em}	[minimum_disk_write_ bytes]{.functionname}
[bool]{.em}	[mmc_co ntrol]{.functionname}
[ARDOUR.FastWindOp ](#ARDOUR.FastWindOp)	[mmc_fast_wi nd_op]{.functionname}
[int]{.em}	[mmc_receive_devi ce_id]{.functionname}
[int]{.em}	[mmc_send_devi ce_id]{.functionname}
[std::string]{.em}	[mo nitor_bus_preferred_b undle]{.functionname}
[ ARDOUR.MonitorModel]( #ARDOUR.MonitorModel)	[monitoring_ model]{.functionname}
[int]{.em}	[mtc_qf_speed_tole rance]{.functionname}
[bool]{.em}	[mute_affects_control _outs]{.functionname}
[bool]{.em}	[mute_affects_main _outs]{.functionname}
[bool]{.em}	[mute_affects_post_ fader]{.functionname}
[bool]{.em}	[mute_affects_pre_ fader]{.functionname}
[bool]{.em}	[m ute_affects_surround_ sends]{.functionname}
[bool]{.em}	[new_plugins_a ctive]{.functionname}
[unsigned int]{.em}	[osc _port]{.functionname}
[ARDOUR.Aut oConnectOption](#ARDO UR.AutoConnectOption)	[output_auto_co nnect]{.functionname}
[unsigned int]{.em}	[perio dic_safety_backup_int erval]{.functionname}
[bool]{.em}	[periodic_safety_ba ckups]{.functionname}
[ARDOUR.PFLPosition] (#ARDOUR.PFLPosition)	[pfl_pos ition]{.functionname}
[std::string]{.em}	[pingbac k_url]{.functionname}
[unsigned int]{.em}	[plugin_cache_ve rsion]{.functionname}
[std::string]{.em}	[plugin_path_ lxvst]{.functionname}
[std::string]{.em}	[plugin_pat h_vst]{.functionname}
[std::string]{.em}	[plugin_path _vst3]{.functionname}
[unsigned int]{.em}	[plugin_scan_ti meout]{.functionname}
[bool]{.em}	[p lugins_stop_with_tran sport]{.functionname}
[unsigned int]{.em}	[port_resampler_qu ality]{.functionname}
[float]{.em}	[ppqn_factor_for_e xport]{.functionname}
[ Temporal.TimeDomain]( #Temporal.TimeDomain)	[preferred_time_d omain]{.functionname}
[float]{.em}	[preroll_se conds]{.functionname}
[int]{.em}	[processor_ usage]{.functionname}
[bool]{.em}	[quieten_at_ speed]{.functionname}
[long]{.em}	[range_location_mi nimum]{.functionname}
[ARD OUR.RangeSelectionAft erSplit](#ARDOUR.Rang eSelectionAfterSplit)	[r ange_selection_after_ split]{.functionname}
[bool]{.em}	[r ecording_resets_xrun_ count]{.functionname}
[std::string]{.em}	[reference_manua l_url]{.functionname}
[bool]{.em}	[region_bound aries_from_onscreen_t racks]{.functionname}
[bool]{.em}	[region_bound aries_from_selected_t racks]{.functionname}
[ARDOUR.Reg ionEquivalence](#ARDO UR.RegionEquivalence)	[region_equiva lence]{.functionname}
[ARDOU R.RegionSelectionAfte rSplit](#ARDOUR.Regio nSelectionAfterSplit)	[re gion_selection_after_ split]{.functionname}
[bool]{.em}	[replica te_missing_region_cha nnels]{.functionname}
[bool]{.em}	[r eset_default_speed_on _stop]{.functionname}
[std::string]{.em}	[resource_inde x_url]{.functionname}
[bool]{.em}	[re store_hardware_connec tions]{.functionname}
[bool]{.em}	[r ewind_ffwd_like_tape_ decks]{.functionname}
[ARDOUR.RippleMode ](#ARDOUR.RippleMode)	[ripple _mode]{.functionname}
[bool]{.em}	[roll_will _loop]{.functionname}
[bool]{.em}	[run_al l_transport_masters_a lways]{.functionname}
[std::string]{.em}	[sample_lib _path]{.functionname}
[bool]{.em}	[save_hi story]{.functionname}
[int]{.em}	[saved_history_ depth]{.functionname}
[bool]{.em}	[sen d_ltc]{.functionname}
[bool]{.em}	[send_midi_ clock]{.functionname}
[bool]{.em}	[sen d_mmc]{.functionname}
[bool]{.em}	[sen d_mtc]{.functionname}
[bool]{.em}	[setup_side chain]{.functionname}
[bool]{.em}	[show_solo_ mutes]{.functionname}
[bool]{.em}	[show_video_server_d ialog]{.functionname}
[bool]{.em}	[s how_vst3_micro_edit_i nline]{.functionname}
[float]{.em}	[shuttle_max_ speed]{.functionname}
[float]{.em}	[shuttle_speed_f actor]{.functionname}
[float]{.em}	[shuttle_speed_thre shold]{.functionname}
[ ARDOUR.ShuttleUnits]( #ARDOUR.ShuttleUnits)	[shuttle_ units]{.functionname}
[bool]{.em}	[skip_pla yback]{.functionname}
[bool]{.em}	[solo _control_is_listen_co ntrol]{.functionname}
[float]{.em}	[solo_mute _gain]{.functionname}
[bool]{.em}	[solo_mute_ove rride]{.functionname}
[bool]{.em}	[stop_at_sessio n_end]{.functionname}
[bool]{.em}	[stop_on _grid]{.functionname}
[bool]{.em}	[stop_recording_on _xrun]{.functionname}
[bool]{.em}	[stri ct_io]{.functionname}
[float]{.em}	[tail_duratio n_sec]{.functionname}
[bool]{.em}	[timecode_sync_frame _rate]{.functionname}
[bool]{.em}	[trace_midi_ input]{.functionname}
[bool]{.em}	[trace_midi_o utput]{.functionname}
[ARDOUR.TracksAut oNamingRule](#ARDOUR. TracksAutoNamingRule)	[tracks_auto_n aming]{.functionname}
[float]{.em}	[transient_sensit ivity]{.functionname}
[bool]{.em}	[transport_master s_just_roll_when_sync _lost]{.functionname}
[bool]{.em}	[try_autostart_e ngine]{.functionname}
[std::string]{.em}	[tutorial_manua l_url]{.functionname}
[std::string]{.em}	[update s_url]{.functionname}
[bool]{.em}	[use_audio_ units]{.functionname}
[bool]{.em}	[use_click_emp hasis]{.functionname}
[bool]{.em}	[use_ lxvst]{.functionname}
[bool]{.em}	[use_m acvst]{.functionname}
[bool]{.em}	[use_master_v olume]{.functionname}
[bool]{.em}	[use_monito r_bus]{.functionname}
[bool]{.em}	[us e_osc]{.functionname}
[bool]{.em}	[use_plugin_ow n_gui]{.functionname}
[bool]{.em}	[use _vst3]{.functionname}
[bool]{.em}	[use_window s_vst]{.functionname}
[bool]{.em}	[verbose_plugin _scan]{.functionname}
[bool]{.em}	[ verify_remove_last_ca pture]{.functionname}
[bool]{.em}	[video_advanced_ setup]{.functionname}
[std::string]{.em}	[video_server_do croot]{.functionname}
[std::string]{.em}	[video_serve r_url]{.functionname}
[ ARDOUR.VST3KnobMode]( #ARDOUR.VST3KnobMode)	[vst3_knob _mode]{.functionname}
[bool]{.em}	[work_around _jack_no_copy_optimiz ation]{.functionname}
[std::string]{.em}	[xjadeo_b inary]{.functionname}

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:RawMidiParser

C‡: ARDOUR::RawMidiParser

Constructor
ℂ	ARDOUR.RawMidiParser ()
Methods
unsigned long	buffer_size ()
unsigned char*	midi_buffer ()
bool	process_byte (unsigned char)
void	reset ()

↠ ARDOUR:ReadOnlyControl

C‡: std::shared_ptr< ARDOUR::ReadOnlyControl >, std::weak_ptr< ARDOUR::ReadOnlyControl >

is-a: PBD:StatefulDestructiblePtr

Methods
ParameterDescriptor	desc ()
std::string	describe_parameter ()
double	get_parameter ()
bool	isnil ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:Readable

C‡: std::shared_ptr< ARDOUR::AudioReadable >, std::weak_ptr< ARDOUR::AudioReadable >

Methods
bool	isnil ()
ReadableList	load (Session&, std::string)
unsigned int	n_channels ()
long	read (FloatArray, long, long, int)
long	readable_length ()

∁ ARDOUR:ReadableList

C‡: std::vector<std::shared_ptr<ARDOUR::AudioReadable> >

Constructor
ℂ	ARDOUR.ReadableList ()
ℂ	ARDOUR.ReadableList ()
Methods
LuaTable	add (LuaTable {Readable})
Readable	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (Readable)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

↠ ARDOUR:Region

C‡: std::shared_ptr< ARDOUR::Region >, std::weak_ptr< ARDOUR::Region >

is-a: ARDOUR:SessionObjectPtr

A named object associated with a Session. Objects derived from this class are expected to be destroyed before the session calls drop_references().

Methods
[bool]{.em}	[add_pl ugin]{.functionname}[ ([RegionFxPlugin](#AR DOUR:RegionFxPlugin), [RegionFxPlugin ](#ARDOUR:RegionFxPlu gin))]{.functionargs}
[bool]{.em}	[at_natural_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[autom atic]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[can_ move]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[capt ured]{.functionname}[ ()]{.functionargs}
[void]{.em}	[captured_x runs]{.functionname}[ ([XrunPositions&](#A RDOUR:XrunPositions), [bool]{ .em})]{.functionargs}
[void]{.em}	[clear_sync_posi tion]{.functionname}[ ()]{.functionargs}
[Cont rol](#Evoral:Control)	[con trol]{.functionname}[ ([Parameter ](#Evoral:Parameter), [bool]{ .em})]{.functionargs}
[bool]{.em}	[co vers]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[cut _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[cut_f ront]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[DataTy pe](#ARDOUR:DataType)	[data_ type]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[exte rnal]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[has_transi ents]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[hi dden]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[im port]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_comp ound]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[l ayer]{.functionname}[ ()]{.functionargs}
[timecnt_t] (#Temporal:timecnt_t)	[le ngth]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[load_pl ugin]{.functionname}[ ([PluginType] (#ARDOUR:PluginType), [std::string]{ .em})]{.functionargs}
[bool]{.em}	[lo cked]{.functionname}[ ()]{.functionargs}
[void]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[void]{.em}	[lower_to_bo ttom]{.functionname}[ ()]{.functionargs}
[StringVec tor](#C:StringVector)	[master_source_n ames]{.functionname}[ ()]{.functionargs}
[SourceList ](#ARDOUR:SourceList)	[master_sou rces]{.functionname}[ ()]{.functionargs}
[void]{.em}	[move_s tart]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[void]{.em}	[move_to_natural_posi tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[m uted]{.functionname}[ ()]{.functionargs}
[RegionFxPlugin](#A RDOUR:RegionFxPlugin)	[nth_pl ugin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[void]{.em}	[nudge_posi tion]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[bool]{.em}	[op aque]{.functionname}[ ()]{.functionargs}
[Playli st](#ARDOUR:Playlist)	[play list]{.functionname}[ ()]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[posi tion]{.functionname}[ ()]{.functionargs}
	::: dox How the region parameters play together: POSITION: first sample of the region along the timeline START: first sample of the region within its source(s) LENGTH: number of samples the region represents ::
[bool]{.em}	[position_lo cked]{.functionname}[ ()]{.functionargs}
[void]{.em}	[r aise]{.functionname}[ ()]{.functionargs}
[void]{.em}	[raise_to _top]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[remove_pl ugin]{.functionname}[ ([RegionFxPlugin](#AR DOUR:RegionFxPlugin), [RegionFxPlugin ](#ARDOUR:RegionFxPlu gin))]{.functionargs}
[void]{.em}	[set_hi dden]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_initial_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_le ngth]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[void]{.em}	[set_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_m uted]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Note: changing the name of a Region does not constitute an edit ::
[void]{.em}	[set_op aque]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_position_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_s tart]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_sync_posi tion]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[set_video_lo cked]{.functionname}[ ([bool]{ .em})]{.functionargs}
[float]{.em}	[s hift]{.functionname}[ ()]{.functionargs}
[So urce](#ARDOUR:Source)	[so urce]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[s tart]{.functionname}[ ()]{.functionargs}
[float]{.em}	[str etch]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[sync_ma rked]{.functionname}[ ()]{.functionargs}
*L uaTable*([timecnt_t]( #Temporal:timecnt_t), ...)	[sync_of fset]{.functionname}[ ([int&]{ .em})]{.functionargs}
[timepos_t] (#Temporal:timepos_t)	[sync_posi tion]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Sync position in session time ::: ::
[Int 64List](#C:Int64List)	[transi ents]{.functionname}[ ()]{.functionargs}
[void]{.em}	[trim _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[trim_f ront]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[tri m_to]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timecn t_t](#Temporal:timecn t_t))]{.functionargs}
[bool]{.em}	[video_lo cked]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[whole_ file]{.functionname}[ ()]{.functionargs}
Cast
[AudioRegion] (#ARDOUR:AudioRegion)	[to_audiore gion]{.functionname}[ ()]{.functionargs}
[MidiRegion ](#ARDOUR:MidiRegion)	[to_midire gion]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:RegionFactory

C‡: ARDOUR::RegionFactory

Methods
Region	clone_region (Region, bool, bool)
Region	region_by_id (ID)
RegionMap	regions ()

↠ ARDOUR:RegionFxPlugin

C‡: std::shared_ptr< ARDOUR::RegionFxPlugin >, std::weak_ptr< ARDOUR::RegionFxPlugin >

is-a: ARDOUR:SessionObjectPtr

A named object associated with a Session. Objects derived from this class are expected to be destroyed before the session calls drop_references().

Methods
unsigned int	get_count ()
bool	isnil ()
Plugin	plugin (unsigned int)
bool	reset_parameters_to_default ()
long	signal_latency ()
PluginType	_type ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:RegionList

C‡: std::list<std::shared_ptr<ARDOUR::Region> >

Constructor
ℂ	ARDOUR.RegionList ()
Methods
Region	back ()
bool	empty ()
Region	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:RegionListPtr

C‡: std::shared_ptr<std::list<std::shared_ptr<ARDOUR::Region> > >

Constructor
ℂ	ARDOUR.RegionListPtr ()
Methods
LuaTable	add (LuaTable {Region})
void	clear ()
bool	empty ()
ARDOUR.RegionListPtr	from_regionlist (RegionList)
LuaIter	iter ()
void	push_back (Region)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ARDOUR:RegionMap

C‡: std::map<PBD::ID, std::shared_ptr<ARDOUR::Region> > >

Constructor
ℂ	ARDOUR.RegionMap ()
Methods
LuaTable	add (LuaTable {Region})
.…	at (–lua–)
void	clear ()
unsigned long	count (ID)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:RegionVector

C‡: std::vector<std::shared_ptr<ARDOUR::Region> >

Constructor
ℂ	ARDOUR.RegionVector ()
ℂ	ARDOUR.RegionVector ()
Methods
LuaTable	add (LuaTable {Region})
Region	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (Region)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

↠ ARDOUR:Return

C‡: std::shared_ptr< ARDOUR::Return >, std::weak_ptr< ARDOUR::Return >

is-a: ARDOUR:IOProcessor

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:IOProcessor

Methods
IO	input ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
IO	output ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:Route

C‡: std::shared_ptr< ARDOUR::Route >, std::weak_ptr< ARDOUR::Route >

is-a: ARDOUR:Stripable, PBD:Stateful

Base class for objects with saveable and undoable state

Methods
[bool]{.em}	[ac tive]{.functionname}[ ()]{.functionargs}
[int]{.em}	[add_aux_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox Add an aux send to a route. route : route to send to. before : Processor to insert before, or 0 to insert at the end. ::
[int]{.em}	[add_foldback_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [bool]{ .em})]{.functionargs}
[int]{.em}	[add_processor_by_i ndex]{.functionname}[ ([Processor ](#ARDOUR:Processor), [int]{.em}, [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[bool]{.em}	[add_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[Amp](#ARDOUR:Amp)	[amp]{.functionname}[ ()]{.functionargs}
[void]{.em}	[clear_stripa bles]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[com ment]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[customize_plugin_in sert]{.functionname}[ ([Processor ](#ARDOUR:Processor), [unsigned int]{.em}, [ChanCount ](#ARDOUR:ChanCount), [Chan Count](#ARDOUR:ChanCo unt))]{.functionargs}
[DataTy pe](#ARDOUR:DataType)	[data_ type]{.functionname}[ ()]{.functionargs}
[Stripabl e](#ARDOUR:Stripable)	[first_selected_strip able]{.functionname}[ ()]{.functionargs}
[IO](#ARDOUR:IO)	[i nput]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[Delive ry](#ARDOUR:Delivery)	[main_ outs]{.functionname}[ ()]{.functionargs}
[MonitorControl](#A RDOUR:MonitorControl)	[monitoring_con trol]{.functionname}[ ()]{.functionargs}
[MonitorState]( #ARDOUR.MonitorState)	[monitoring_s tate]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[m uted]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_in puts]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_out puts]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_pl ugin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_proce ssor]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_ send]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[IO](#ARDOUR:IO)	[ou tput]{.functionname}[ ()]{.functionargs}
[PannerShell] (#ARDOUR:PannerShell)	[panner_s hell]{.functionname}[ ()]{.functionargs}
[PeakMete r](#ARDOUR:PeakMeter)	[peak_m eter]{.functionname}[ ()]{.functionargs}
[long]{.em}	[playback_lat ency]{.functionname}[ ([bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[remove_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[int]{.em}	[reorder_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[int]{.em}	[replace_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processor ](#ARDOUR:Processor), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[reset_plugin_in sert]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox reset plugin-insert configuration to default, disable customizations. This is equivalent to calling customize_plugin_ins ert (proc, 0, unused) proc : Processor to reset ::: result-discussion [Re turns]{.word-returns} true if successful ::: ::
[int]{.em}	[save_as_temp late]{.functionname}[ ([std::string]{.em}, [std::string]{.em}, [std::string]{ .em})]{.functionargs}
[void]{.em}	[select_next_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[select_prev_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[set_ac tive]{.functionname}[ ([bool]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_com ment]{.functionname}[ ([std::string]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_meter_p oint]{.functionname}[ ([MeterP oint](#ARDOUR.MeterPo int))]{.functionargs}
[bool]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[bool]{.em}	[set_stric t_io]{.functionname}[ ([bool]{ .em})]{.functionargs}
[long]{.em}	[signal_lat ency]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[so loed]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[stric t_io]{.functionname}[ ()]{.functionargs}
[SurroundReturn](#A RDOUR:SurroundReturn)	[surround_re turn]{.functionname}[ ()]{.functionargs}
[SurroundSend]( #ARDOUR:SurroundSend)	[surround_ send]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[the_instru ment]{.functionname}[ ()]{.functionargs}
	::: dox Return the first processor that accepts has at least one MIDI input and at least one audio output. In the vast majority of cases, this will be "the instrument". This does not preclude other MIDI->audio processors later in the processing chain, but that would be a special case not covered by this utility function. ::
[Amp](#ARDOUR:Amp)	[ trim]{.functionname}[ ()]{.functionargs}
Cast
[ Track](#ARDOUR:Track)	[to_t rack]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Stripable

Methods
unsigned int	eq_band_cnt ()
std::string	eq_band_name (unsigned int)
GainControl	gain_control ()
bool	is_auditioner ()
bool	is_hidden ()
bool	is_master ()
bool	is_monitor ()
bool	is_private_route ()
bool	is_selected ()
bool	is_surround_master ()
AutomationControl	mapped_control (WellKnownCtrl, unsigned int)
ReadOnlyControl	mapped_output (WellKnownData)
AutomationControl	master_send_enable_controllable ()
MonitorProcessor	monitor_control ()
MuteControl	mute_control ()
AutomationControl	pan_azimuth_control ()
AutomationControl	pan_elevation_control ()
AutomationControl	pan_frontback_control ()
AutomationControl	pan_lfe_control ()
AutomationControl	pan_width_control ()
PhaseControl	phase_control ()
PresentationInfo	presentation_info_ptr ()
AutomationControl	rec_enable_control ()
AutomationControl	rec_safe_control ()
AutomationControl	send_enable_controllable (unsigned int)
AutomationControl	send_level_controllable (unsigned int, bool)
std::string	send_name (unsigned int)
AutomationControl	send_pan_azimuth_controllable (unsigned int)
AutomationControl	send_pan_azimuth_enable_controllable (unsigned int)
void	set_presentation_order (unsigned int)
bool	slaved ()
bool	slaved_to (VCA)
SoloControl	solo_control ()
SoloIsolateControl	solo_isolate_control ()
SoloSafeControl	solo_safe_control ()
GainControl	trim_control ()
Cast
Automatable	to_automatable ()
Route	to_route ()
Slavable	to_slavable ()
VCA	to_vca ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:Route:ProcessorStreams

C‡: ARDOUR::Route::ProcessorStreams

A record of the stream configuration at some point in the processor list. Used to return where and why an processor list configuration request failed.

Constructor
ℂ	ARDOUR.Route.ProcessorStreams ()

↠ ARDOUR:RouteGroup

C‡: std::shared_ptr< ARDOUR::RouteGroup >, std::weak_ptr< ARDOUR::RouteGroup >

is-a: ARDOUR:SessionObjectPtr

A group identifier for routes.

RouteGroups permit to define properties which are shared among all Routes that use the given identifier.

A route can at most be in one group.

Constructor
ℵ	[ARDOUR.RouteG roup]{.functionname}[ ()]{.functionargs}
Methods
[int]{.em}	[add]{.functionname}[ ([Route](#ARDOUR:Ro ute))]{.functionargs}
	::: dox Add a route to a group. Adding a route which is already in the group is allowed; nothing will happen. r : Route to add. ::
[void]{.em}	[c lear]{.functionname}[ ()]{.functionargs}
[void]{.em}	[destroy_subg roup]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[e mpty]{.functionname}[ ()]{.functionargs}
[int]{.em}	[group_master_nu mber]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[has_subg roup]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_ac tive]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_c olor]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_ gain]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_hi dden]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_monito ring]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_ mute]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_recen able]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_rela tive]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_route_ac tive]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_se lect]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[is_ solo]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[void]{.em}	[make_subg roup]{.functionname}[ ([bool]{.em}, [Plac ement](#ARDOUR.Placem ent))]{.functionargs}
[int]{.em}	[re move]{.functionname}[ ([Route](#ARDOUR:Ro ute))]{.functionargs}
[unsigned int]{.em}	[ rgba]{.functionname}[ ()]{.functionargs}
[RouteListPtr]( #ARDOUR:RouteListPtr)	[route_ list]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_ac tive]{.functionname}[ ([bool]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_c olor]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_ gain]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_hi dden]{.functionname}[ ([bool]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_monito ring]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_ mute]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_recen able]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_rela tive]{.functionname}[ ([bool]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_ rgba]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox set route-group color and notify UI about change ::
[void]{.em}	[set_route_ac tive]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_se lect]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_ solo]{.functionname}[ ([bool]{ .em})]{.functionargs}
[unsigned long]{.em}	[ size]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:RouteGroupList

C‡: std::list<std::shared_ptr<ARDOUR::RouteGroup> >

Constructor
ℂ	ARDOUR.RouteGroupList ()
Methods
LuaTable	add (LuaTable {RouteGroup})
RouteGroup	back ()
void	clear ()
bool	empty ()
RouteGroup	front ()
LuaIter	iter ()
void	push_back (RouteGroup)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ARDOUR:RouteList

C‡: std::list<std::shared_ptr<ARDOUR::Route> >

Constructor
ℂ	ARDOUR.RouteList ()
Methods
Route	back ()
bool	empty ()
Route	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:RouteListPtr

C‡: std::shared_ptr<std::list<std::shared_ptr<ARDOUR::Route> > >

Constructor
ℂ	ARDOUR.RouteListPtr ()
Methods
LuaTable	add (LuaTable {Route})
void	clear ()
bool	empty ()
ARDOUR.RouteListPtr	from_routelist (RouteList)
LuaIter	iter ()
void	push_back (Route)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ARDOUR:RouteStateMap

C‡: std::map<PBD::ID, ARDOUR::Session::RouteImportInfo >

Constructor
ℂ	ARDOUR.RouteStateMap ()
Methods
LuaTable	add (PBD::ID, ARDOUR::Session::RouteImportInfo )
.…	at (–lua–)
void	clear ()
unsigned long	count (ID)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

↠ ARDOUR:Send

C‡: std::shared_ptr< ARDOUR::Send >, std::weak_ptr< ARDOUR::Send >

is-a: ARDOUR:Delivery

Internal Abstraction for Sends (and MixbusSends)

Methods
GainControl	gain_control ()
long	get_delay_in ()
long	get_delay_out ()
bool	is_foldback ()
bool	isnil ()
void	set_remove_on_disconnect (bool)
Cast
InternalSend	to_internalsend ()

Inherited from ARDOUR:Delivery

Methods
PannerShell	panner_shell ()

Inherited from ARDOUR:IOProcessor

Methods
IO	input ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
IO	output ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:Session

C‡: ARDOUR::Session

is-a: PBD:HistoryOwner

Methods
[bool]{.em}	[actively_recor ding]{.functionname}[ ()]{.functionargs}
[double]{.em}	[actual_s peed]{.functionname}[ ()]{.functionargs}
[void]{.em}	[add_internal_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [Processor ](#ARDOUR:Processor), [Route](#ARDOUR:Ro ute))]{.functionargs}
[void]{.em}	[add_internal_s ends]{.functionname}[ ([R oute](#ARDOUR:Route), [Placement ](#ARDOUR.Placement), [RouteListP tr](#ARDOUR:RouteList Ptr))]{.functionargs}
[int]{.em}	[add_master _bus]{.functionname}[ ([Chan Count](#ARDOUR:ChanCo unt))]{.functionargs}
[void]{.em}	[add_route_g roup]{.functionname}[ ([RouteG roup](#ARDOUR:RouteGr oup))]{.functionargs}
[bool]{.em}	[apply_nth_mixer_s cene]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
[bool]{.em}	[apply_nth_mixer_scen e_to]{.functionname}[ ([unsigned long]{.em}, [Rout eList](#ARDOUR:RouteL ist))]{.functionargs}
[Const BundleListPtr](#ARDOU R:ConstBundleListPtr)	[bun dles]{.functionname}[ ()]{.functionargs}
[void]{.em}	[cancel_all_ solo]{.functionname}[ ()]{.functionargs}
[SessionCo nfiguration](#ARDOUR: SessionConfiguration)	[cfg]{.functionname}[ ()]{.functionargs}
[void]{.em}	[clear_all_solo_s tate]{.functionname}[ ( [ConstRouteListPtr](# ARDOUR:ConstRouteList Ptr))]{.functionargs}
[Controllabl e](#PBD:Controllable)	[controllable_b y_id]{.functionname}[ ([ID](#PBD :ID))]{.functionargs}
[long]{.em}	[current_end_sa mple]{.functionname}[ ()]{.functionargs}
[long]{.em}	[current_start_sa mple]{.functionname}[ ()]{.functionargs}
[void]{.em}	[cut_copy_sec tion]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepos_t]( #Temporal:timepos_t), [timepos_t]( #Temporal:timepos_t), [SectionOperation]( #ARDOUR.SectionOperat ion))]{.functionargs}
[void]{.em}	[disable_re cord]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[bool]{.em}	[e mpty]{.functionname}[ ()]{.functionargs}
[AudioEngine] (#ARDOUR:AudioEngine)	[en gine]{.functionname}[ ()]{.functionargs}
[double]{.em}	[engine_s peed]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[export_route_s tate]{.functionname}[ ([RouteListPtr](# ARDOUR:RouteListPtr), [std::string]{.em}, [bool]{ .em})]{.functionargs}
[unsigned int]{.em}	[get_block_ size]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[get_play_ loop]{.functionname}[ ()]{.functionargs}
[ Route](#ARDOUR:Route)	[get_remote_nth_r oute]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Stripabl e](#ARDOUR:Stripable)	[get_remote_nth_strip able]{.functionname}[ ([unsigned int]{.em}, [Flag](#ARDO UR.PresentationInfo.F lag))]{.functionargs}
[RouteLis t](#ARDOUR:RouteList)	[get_route list]{.functionname}[ ([bool]{.em}, [Flag](#ARDO UR.PresentationInfo.F lag))]{.functionargs}
[Con stRouteListPtr](#ARDO UR:ConstRouteListPtr)	[get_ro utes]{.functionname}[ ()]{.functionargs}
[BufferSe t](#ARDOUR:BufferSet)	[get_scratch_buf fers]{.functionname}[ ([ChanCount ](#ARDOUR:ChanCount), [bool]{ .em})]{.functionargs}
[BufferSe t](#ARDOUR:BufferSet)	[get_silent_buf fers]{.functionname}[ ([Chan Count](#ARDOUR:ChanCo unt))]{.functionargs}
[StripableList](# ARDOUR:StripableList)	[get_stripa bles]{.functionname}[ ()]{.functionargs}
[RouteListPtr]( #ARDOUR:RouteListPtr)	[get_tr acks]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[get_xrun_c ount]{.functionname}[ ()]{.functionargs}
[void]{.em}	[goto _end]{.functionname}[ ()]{.functionargs}
[void]{.em}	[goto_s tart]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[have_external_connec tions_for_current_bac kend]{.functionname}[ ([bool]{ .em})]{.functionargs}
[int]{.em}	[import_route_s tate]{.functionname}[ ([std::string]{.em}, [I DMap](#ARDOUR:IDMap), [RouteGroupImportMo de](#ARDOUR.Session.R outeGroupImportMode), [Progress](#PBD:Progr ess))]{.functionargs}
[long]{.em}	[io_lat ency]{.functionname}[ ()]{.functionargs}
[long]{.em}	[last_transport_s tart]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[liste ning]{.functionname}[ ()]{.functionargs}
[Location s](#ARDOUR:Locations)	[locat ions]{.functionname}[ ()]{.functionargs}
[ Route](#ARDOUR:Route)	[master _out]{.functionname}[ ()]{.functionargs}
[GainControl] (#ARDOUR:GainControl)	[master_vo lume]{.functionname}[ ()]{.functionargs}
[void]{.em}	[maybe_enable_re cord]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[m aybe_update_session_r ange]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[ Route](#ARDOUR:Route)	[monitor _out]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[naudiotr acks]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[nbu sses]{.functionname}[ ()]{.functionargs}
[RouteLis t](#ARDOUR:RouteList)	[new_audio_r oute]{.functionname}[ ([int]{.em}, [int]{.em}, [RouteGroup] (#ARDOUR:RouteGroup), [unsigned int]{.em}, [std::string]{.em}, [Flag](#ARDOUR.Pr esentationInfo.Flag), [unsigned int]{ .em})]{.functionargs}
[AudioTrackList](#A RDOUR:AudioTrackList)	[new_audio_t rack]{.functionname}[ ([int]{.em}, [int]{.em}, [RouteGroup] (#ARDOUR:RouteGroup), [unsigned int]{.em}, [std::string]{.em}, [unsigned int]{.em}, [TrackMode ](#ARDOUR.TrackMode), [bool]{.em}, [bool]{ .em})]{.functionargs}
[RouteLis t](#ARDOUR:RouteList)	[new_midi_r oute]{.functionname}[ ([RouteGroup] (#ARDOUR:RouteGroup), [unsigned int]{.em}, [std::string]{.em}, [bool]{.em}, [PluginInfo] (#ARDOUR:PluginInfo), [PresetRecord](# ARDOUR:PresetRecord), [Flag](#ARDOUR.Pr esentationInfo.Flag), [unsigned int]{ .em})]{.functionargs}
[MidiTrackList](# ARDOUR:MidiTrackList)	[new_midi_t rack]{.functionname}[ ([ChanCount ](#ARDOUR:ChanCount), [ChanCount ](#ARDOUR:ChanCount), [bool]{.em}, [PluginInfo] (#ARDOUR:PluginInfo), [PresetRecord](# ARDOUR:PresetRecord), [RouteGroup] (#ARDOUR:RouteGroup), [unsigned int]{.em}, [std::string]{.em}, [unsigned int]{.em}, [TrackMode ](#ARDOUR.TrackMode), [bool]{.em}, [bool]{ .em})]{.functionargs}
[RouteLis t](#ARDOUR:RouteList)	[new_route_from_temp late]{.functionname}[ ([unsigned int]{.em}, [unsigned int]{.em}, [std::string]{.em}, [std::string]{.em}, [Pla ylistDisposition](#AR DOUR.PlaylistDisposit ion))]{.functionargs}
[RouteGroup ](#ARDOUR:RouteGroup)	[new_route_g roup]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[long]{.em}	[nominal_sample_ rate]{.functionname}[ ()]{.functionargs}
	::: dox "native" sample rate of session, regardless of current audioengine rate, pullup/down etc ::
[unsigned int]{.em}	[nro utes]{.functionname}[ ()]{.functionargs}
[MixerScene ](#ARDOUR:MixerScene)	[nth_mixer_s cene]{.functionname}[ ([unsigned long]{.em}, [bool]{ .em})]{.functionargs}
[bool]{.em}	[nth_mixer_scene_v alid]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
[unsigned int]{.em}	[ntr acks]{.functionname}[ ()]{.functionargs}
[RouteStateMap](# ARDOUR:RouteStateMap)	[parse_route_s tate]{.functionname}[ ([std::string]{.em}, [bool&]{ .em})]{.functionargs}
[std::string]{.em}	[ path]{.functionname}[ ()]{.functionargs}
[S essionPlaylists](#ARD OUR:SessionPlaylists)	[playl ists]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[plot_process_g raph]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[long]{.em}	[preroll_sam ples]{.functionname}[ ([long]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[processor_b y_id]{.functionname}[ ([ID](#PBD :ID))]{.functionargs}
[RecordState] (#ARDOUR.RecordState)	[record_st atus]{.functionname}[ ()]{.functionargs}
[void]{.em}	[remove_r oute]{.functionname}[ ([Route](#ARDOUR:Ro ute))]{.functionargs}
[void]{.em}	[remove_route_g roup]{.functionname}[ ([RouteG roup](#ARDOUR:RouteGr oup))]{.functionargs}
[void]{.em}	[remove_ro utes]{.functionname}[ ([RouteListP tr](#ARDOUR:RouteList Ptr))]{.functionargs}
[int]{.em}	[re name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[void]{.em}	[request_bounded_ roll]{.functionname}[ ([long]{.em}, [long]{ .em})]{.functionargs}
[void]{.em}	[request_count_in_re cord]{.functionname}[ ()]{.functionargs}
[void]{.em}	[request_lo cate]{.functionname}[ ([long]{.em}, [bool]{.em}, [L ocateTransportDisposi tion](#ARDOUR.LocateT ransportDisposition), [Transport RequestSource](#ARDOU R.TransportRequestSou rce))]{.functionargs}
[bool]{.em}	[request_locate_to_ mark]{.functionname}[ ([std::string]{.em}, [L ocateTransportDisposi tion](#ARDOUR.LocateT ransportDisposition), [Transport RequestSource](#ARDOU R.TransportRequestSou rce))]{.functionargs}
[void]{.em}	[request_play_ loop]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[re quest_preroll_record_ trim]{.functionname}[ ([long]{.em}, [long]{ .em})]{.functionargs}
[void]{.em}	[request_ roll]{.functionname}[ ([Transport RequestSource](#ARDOU R.TransportRequestSou rce))]{.functionargs}
[void]{.em}	[request_ stop]{.functionname}[ ([bool]{.em}, [bool]{.em}, [Transport RequestSource](#ARDOU R.TransportRequestSou rce))]{.functionargs}
[void]{.em}	[request_transport_s peed]{.functionname}[ ([double]{.em}, [Transport RequestSource](#ARDOU R.TransportRequestSou rce))]{.functionargs}
[void]{.em}	[reset_xrun_c ount]{.functionname}[ ()]{.functionargs}
[ Route](#ARDOUR:Route)	[route_b y_id]{.functionname}[ ([ID](#PBD :ID))]{.functionargs}
[ Route](#ARDOUR:Route)	[route_by_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[ Route](#ARDOUR:Route)	[route_by_selected_c ount]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[RouteGroupList](#A RDOUR:RouteGroupList)	[route_gr oups]{.functionname}[ ()]{.functionargs}
[long]{.em}	[sample_ rate]{.functionname}[ ()]{.functionargs}
	::: dox "actual" sample rate of session, set by current audioengine rate, pullup/down etc. ::
...	[sample_to_timecode _lua]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
[double]{.em}	[s amples_per_timecode_f rame]{.functionname}[ ()]{.functionargs}
[int]{.em}	[save_s tate]{.functionname}[ ([std::string]{.em}, [bool]{.em}, [bool]{.em}, [bool]{.em}, [bool]{.em}, [bool]{ .em})]{.functionargs}
	::: dox save session snapshot_name : name of the session (use an empty string for the current name) pending : save a 'recovery', not full state (default: false) switch_to_snapshot : switch to given snapshot after saving (default: false) template_only : save a session template (default: false) for_archive : save only data relevant for session-archive only_used_assets : skip Sources that are not used, mainly useful with for_archive ::: result-discussion [Re turns]{.word-returns} zero on success ::: ::
[void]{.em}	[scripts_cha nged]{.functionname}[ ()]{.functionargs}
[ Route](#ARDOUR:Route)	[selec tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[session_range_is_ free]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_con trol]{.functionname}[ ([Auto mationControl](#ARDOU R:AutomationControl), [double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
[void]{.em}	[set_cont rols]{.functionname}[ ([ControlListPtr](#AR DOUR:ControlListPtr), [double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
[void]{.em}	[set_d irty]{.functionname}[ ()]{.functionargs}
[void]{.em}	[s et_exclusive_input_ac tive]{.functionname}[ ([RouteListPtr](# ARDOUR:RouteListPtr), [bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[set_session_ext ents]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[ set_session_range_is_ free]{.functionname}[ ([bool]{ .em})]{.functionargs}
...	[simple_ex port]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
[std::string]{.em}	[snap_ name]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[solo_isol ated]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[sol oing]{.functionname}[ ()]{.functionargs}
[So urce](#ARDOUR:Source)	[source_b y_id]{.functionname}[ ([ID](#PBD :ID))]{.functionargs}
[void]{.em}	[store_nth_mixer_s cene]{.functionname}[ ([unsigned long]{ .em})]{.functionargs}
[Stripabl e](#ARDOUR:Stripable)	[stripable_b y_id]{.functionname}[ ([ID](#PBD :ID))]{.functionargs}
[ Route](#ARDOUR:Route)	[surround_ma ster]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[timecode_drop_fr ames]{.functionname}[ ()]{.functionargs}
[long]{.em}	[timecode_frames_per_ hour]{.functionname}[ ()]{.functionargs}
[double]{.em}	[t imecode_frames_per_se cond]{.functionname}[ ()]{.functionargs}
...	[timecode_to_sample _lua]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
[bool]{.em}	[transport_rol ling]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if the the transport is actively (audible) rolling. playback speed is not zero, and count-in as well as latency-preroll is complete, and _transport_sample changes every process cycle. ::: ::
[long]{.em}	[transport_sa mple]{.functionname}[ ()]{.functionargs}
[double]{.em}	[transport_s peed]{.functionname}[ ([bool]{ .em})]{.functionargs}
[bool]{.em}	[transport_state_rol ling]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if the transport state (TFSM) is rolling. Note: the transport may not yet move if pre-roll or count-in in ongoing. ::: ::
[bool]{.em}	[transport_sto pped]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if the transport state (TFSM) is stopped ::: ::
[bool]{.em}	[tran sport_stopped_or_stop ping]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if the transport state (TFSM) is stopped or stopping ::: ::
[bool]{.em}	[tra nsport_will_roll_forw ards]{.functionname}[ ()]{.functionargs}
[Strin gList](#C:StringList)	[unknown_proces sors]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[unn amed]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[ uuid]{.functionname}[ ()]{.functionargs}
[VCAManager ](#ARDOUR:VCAManager)	[vca_man ager]{.functionname}[ ()]{.functionargs}
[long]{.em}	[worst_input_lat ency]{.functionname}[ ()]{.functionargs}
[long]{.em}	[worst_latency_pre roll]{.functionname}[ ()]{.functionargs}
[long]{.em}	[worst_latency _preroll_buffer_size_ ceil]{.functionname}[ ()]{.functionargs}
[long]{.em}	[worst_output_lat ency]{.functionname}[ ()]{.functionargs}
[long]{.em}	[worst_route_lat ency]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:HistoryOwner

Methods
[bool]{.em}	[abort _empty_reversible_com mand]{.functionname}[ ()]{.functionargs}
	::: dox Abort reversible command IFF no undo changes have been collected. ::: result-discussion [Re turns]{.word-returns} true if undo operation was aborted. ::: ::
[void]{.em}	[abort_reversible_com mand]{.functionname}[ ()]{.functionargs}
	::: dox abort an open undo command This must only be called after beg in_reversible_command () ::
[void]{.em}	[add_com mand]{.functionname}[ ([Command](#PBD:Comm and))]{.functionargs}
[Stat efulDiffCommand](#PBD :StatefulDiffCommand)	[ add_stateful_diff_com mand]{.functionname}[ ([Stateful DestructiblePtr](#PBD :StatefulDestructible Ptr))]{.functionargs}
	::: dox create an StatefulDiffCommand from the given object and add it to the stack. This function must only be called after begi n_reversible_command. Failing to do so may lead to a crash. sfd : the object to diff ::: result-discussion [Re turns]{.word-returns} the allocated StatefulDiffCommand (already added via add_command) ::: ::
[void]{.em}	[begin_reversible_com mand]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox begin collecting undo information This call must always be followed by either begin _reversible_command() or commit _reversible_command() cmd_name : human readable name for the undo operation ::
[bool]{.em}	[collected_undo_comm ands]{.functionname}[ ()]{.functionargs}
	::: dox Test if any undo commands were added since the call to beg in_reversible_command () This is useful to determine if an undoable action was performed before adding additional information (e.g. selection changes) to the undo transaction. ::: result-discussion [Re turns]{.word-returns} true if undo operation is valid but empty ::: ::
[void]{.em}	[ commit_reversible_com mand]{.functionname}[ ([Command](#PBD:Comm and))]{.functionargs}
	::: dox finalize an undo command and commit pending transactions This must only be called after beg in_reversible_command () cmd : (additional) command to add ::

∁ ARDOUR:SessionConfiguration

C‡: ARDOUR::SessionConfiguration

is-a: PBD:Configuration

Base class for objects with saveable and undoable state

Methods
[std::string]{.em}	[get_audio_search_ path]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_auto_i nput]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_auto_ play]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_auto_re turn]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_coun t_in]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[CueBehavior] (#ARDOUR.CueBehavior)	[get_cue_beha vior]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[TimeDomain]( #Temporal.TimeDomain)	[get_default_time_do main]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get _draw_opaque_midi_reg ions]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_external_ sync]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[Ins ertMergePolicy](#ARDO UR.InsertMergePolicy)	[get_insert_merge_po licy]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_jack_time_ma ster]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[unsigned int]{.em}	[get _meterbridge_label_he ight]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_midi_copy_is_ fork]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[std::string]{.em}	[get_midi_search_ path]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[long]{.em}	[get_minitimeline_ span]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[SampleFormat]( #ARDOUR.SampleFormat)	[ge t_native_file_data_fo rmat]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[HeaderFormat]( #ARDOUR.HeaderFormat)	[get_ native_file_header_fo rmat]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_punc h_in]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_punch _out]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[std::string]{.em}	[get_raid_ path]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_realtime_ex port]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[RecordMode ](#ARDOUR.RecordMode)	[get_record_ mode]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[MonitorChoice](# ARDOUR.MonitorChoice)	[get_session_monito ring]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_s how_busses_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_ show_fader_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_show_group_ tabs]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_show_m aster_bus_comment_on_ load]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_s how_master_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get _show_midi_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_sh ow_monitor_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get _show_mute_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get _show_name_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[ge t_show_rec_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_show_region_f ades]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get _show_solo_on_meterbr idge]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_show_sum mary]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[std::string]{.em}	[ get_slave_timecode_of fset]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[unsigned int]{.em}	[get_subframes_per_f rame]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[std::string]{.em}	[get_take_ name]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[TimecodeFormat](#Tim ecode.TimecodeFormat)	[get_timecode_fo rmat]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[std::string]{.em}	[get_ timecode_generator_of fset]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[long]{.em}	[get_timecode_of fset]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get _timecode_offset_nega tive]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_track_name_nu mber]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_track_name_ take]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_t racks_follow_session_ time]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_triggerbox_ overrides_disk_monito ring]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_use_monitor_f ades]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_use_region_f ades]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_use_surround_ma ster]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_use_transport_f ades]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_use_video_file _fps]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_use_video_ sync]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[float]{.em}	[get_video_pu llup]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[get_videotimeline_pu llup]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[double]{.em}	[get_wave_amplitude_ zoom]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[unsigned short]{.em}	[get_wave_zoom_fa ctor]{.functionname}[ ()]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_audio_search_ path]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_auto_i nput]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_auto_ play]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_auto_re turn]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_coun t_in]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_cue_beha vior]{.functionname}[ ([CueBehav ior](#ARDOUR.CueBehav ior))]{.functionargs}
[bool]{.em}	[set_default_time_do main]{.functionname}[ ([TimeDoma in](#Temporal.TimeDom ain))]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set _draw_opaque_midi_reg ions]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_external_ sync]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_insert_merge_po licy]{.functionname}[ ( [InsertMergePolicy](# ARDOUR.InsertMergePol icy))]{.functionargs}
[bool]{.em}	[set_jack_time_ma ster]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set _meterbridge_label_he ight]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_midi_copy_is_ fork]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_midi_search_ path]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_minitimeline_ span]{.functionname}[ ([long]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[se t_native_file_data_fo rmat]{.functionname}[ ([SampleForm at](#ARDOUR.SampleFor mat))]{.functionargs}
[bool]{.em}	[set_ native_file_header_fo rmat]{.functionname}[ ([HeaderForm at](#ARDOUR.HeaderFor mat))]{.functionargs}
[bool]{.em}	[set_punc h_in]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_punch _out]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_raid_ path]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_realtime_ex port]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_record_ mode]{.functionname}[ ([Record Mode](#ARDOUR.RecordM ode))]{.functionargs}
[bool]{.em}	[set_session_monito ring]{.functionname}[ ([MonitorChoic e](#ARDOUR.MonitorCho ice))]{.functionargs}
[bool]{.em}	[set_s how_busses_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_ show_fader_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_show_group_ tabs]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_show_m aster_bus_comment_on_ load]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_s how_master_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set _show_midi_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_sh ow_monitor_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set _show_mute_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set _show_name_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[se t_show_rec_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_show_region_f ades]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set _show_solo_on_meterbr idge]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_show_sum mary]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[ set_slave_timecode_of fset]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_subframes_per_f rame]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_take_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_timecode_fo rmat]{.functionname}[ ([TimecodeFormat]( #Timecode.TimecodeFor mat))]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_ timecode_generator_of fset]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_timecode_of fset]{.functionname}[ ([long]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set _timecode_offset_nega tive]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_track_name_nu mber]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_track_name_ take]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_t racks_follow_session_ time]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_triggerbox_ overrides_disk_monito ring]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_use_monitor_f ades]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_use_region_f ades]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_use_surround_ma ster]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_use_transport_f ades]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_use_video_file _fps]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_use_video_ sync]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_video_pu llup]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_videotimeline_pu llup]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_wave_amplitude_ zoom]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox ********* ********************* ********************* DO NOT USE uint8_t or any other type that resolves to a single char, because the value will be stored incorrectly when serialized. Use int32_t instead and ensure that code correctly limits the value of the variab le.********* ********************* ********************* ::
[bool]{.em}	[set_wave_zoom_fa ctor]{.functionname}[ ([unsigned short]{ .em})]{.functionargs}
Properties
[std::string]{.em}	[audio_search _path]{.functionname}
[bool]{.em}	[auto_ input]{.functionname}
[bool]{.em}	[auto _play]{.functionname}
[bool]{.em}	[auto_r eturn]{.functionname}
[bool]{.em}	[cou nt_in]{.functionname}
[ARDOUR.CueBehavior] (#ARDOUR.CueBehavior)	[cue_beh avior]{.functionname}
[ Temporal.TimeDomain]( #Temporal.TimeDomain)	[default_time_d omain]{.functionname}
[bool]{.em}	[draw_opaque_midi_re gions]{.functionname}
[bool]{.em}	[external _sync]{.functionname}
[ARDOUR.Ins ertMergePolicy](#ARDO UR.InsertMergePolicy)	[insert_merge_p olicy]{.functionname}
[bool]{.em}	[jack_time_m aster]{.functionname}
[unsigned int]{.em}	[meterbridge_label_h eight]{.functionname}
[bool]{.em}	[midi_copy_is _fork]{.functionname}
[std::string]{.em}	[midi_search _path]{.functionname}
[long]{.em}	[minitimeline _span]{.functionname}
[ ARDOUR.SampleFormat]( #ARDOUR.SampleFormat)	[native_file_data_f ormat]{.functionname}
[ ARDOUR.HeaderFormat]( #ARDOUR.HeaderFormat)	[native_file_header_f ormat]{.functionname}
[bool]{.em}	[pun ch_in]{.functionname}
[bool]{.em}	[punc h_out]{.functionname}
[std::string]{.em}	[raid _path]{.functionname}
[bool]{.em}	[realtime_e xport]{.functionname}
[ARDOUR.RecordMode ](#ARDOUR.RecordMode)	[record _mode]{.functionname}
[AR DOUR.MonitorChoice](# ARDOUR.MonitorChoice)	[session_monit oring]{.functionname}
[bool]{.em}	[ show_busses_on_meterb ridge]{.functionname}
[bool]{.em}	[show_fader_on_meterb ridge]{.functionname}
[bool]{.em}	[show_group _tabs]{.functionname}
[bool]{.em}	[show_ master_bus_comment_on _load]{.functionname}
[bool]{.em}	[ show_master_on_meterb ridge]{.functionname}
[bool]{.em}	[show_midi_on_meterb ridge]{.functionname}
[bool]{.em}	[s how_monitor_on_meterb ridge]{.functionname}
[bool]{.em}	[show_mute_on_meterb ridge]{.functionname}
[bool]{.em}	[show_name_on_meterb ridge]{.functionname}
[bool]{.em}	[show_rec_on_meterb ridge]{.functionname}
[bool]{.em}	[show_region_ fades]{.functionname}
[bool]{.em}	[show_solo_on_meterb ridge]{.functionname}
[bool]{.em}	[show_su mmary]{.functionname}
[std::string]{.em}	[slave_timecode_o ffset]{.functionname}
[unsigned int]{.em}	[subframes_per_ frame]{.functionname}
[std::string]{.em}	[take _name]{.functionname}
[Timecode .TimecodeFormat](#Tim ecode.TimecodeFormat)	[timecode_f ormat]{.functionname}
[std::string]{.em}	[timecode_generator_o ffset]{.functionname}
[long]{.em}	[timecode_o ffset]{.functionname}
[bool]{.em}	[timecode_offset_neg ative]{.functionname}
[bool]{.em}	[track_name_n umber]{.functionname}
[bool]{.em}	[track_name _take]{.functionname}
[bool]{.em}	[ tracks_follow_session _time]{.functionname}
[bool]{.em}	[triggerbox _overrides_disk_monit oring]{.functionname}
[bool]{.em}	[use_monitor_ fades]{.functionname}
[bool]{.em}	[use_region_ fades]{.functionname}
[bool]{.em}	[use_surround_m aster]{.functionname}
[bool]{.em}	[use_transport_ fades]{.functionname}
[bool]{.em}	[use_video_fil e_fps]{.functionname}
[bool]{.em}	[use_video _sync]{.functionname}
[float]{.em}	[video_p ullup]{.functionname}
[bool]{.em}	[videotimeline_p ullup]{.functionname}
[double]{.em}	[wave_amplitude _zoom]{.functionname}
[unsigned short]{.em}	[wave_zoom_f actor]{.functionname}

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:SessionObject

C‡: ARDOUR::SessionObject

A named object associated with a Session. Objects derived from this class are expected to be destroyed before the session calls drop_references().

Methods
std::string	name ()
Cast
Stateful	to_stateful ()

↠ ARDOUR:SessionObjectPtr

C‡: std::shared_ptr< ARDOUR::SessionObject >, std::weak_ptr< ARDOUR::SessionObject >

A named object associated with a Session. Objects derived from this class are expected to be destroyed before the session calls drop_references().

Methods
bool	isnil ()
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:SessionPlaylists

C‡: std::shared_ptr< ARDOUR::SessionPlaylists >, std::weak_ptr< ARDOUR::SessionPlaylists >

Methods
Playlist	by_id (ID)
Playlist	by_name (std::string)
PlaylistList	get_unused ()
PlaylistList	get_used ()
bool	isnil ()
unsigned int	n_playlists ()
PlaylistList	playlists_for_track (Track)
unsigned int	region_use_count (Region)
unsigned int	source_use_count (Source)

↠ ARDOUR:SideChain

C‡: std::shared_ptr< ARDOUR::SideChain >, std::weak_ptr< ARDOUR::SideChain >

is-a: ARDOUR:IOProcessor

Base class for objects with saveable and undoable state

Methods
bool	isnil ()

Inherited from ARDOUR:IOProcessor

Methods
IO	input ()
ChanCount	natural_input_streams ()
ChanCount	natural_output_streams ()
IO	output ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:SimpleExport

C‡: ARDOUR::SimpleExport

Methods
bool	check_outputs ()
bool	run_export ()
void	set_folder (std::string)
void	set_name (std::string)
bool	set_preset (std::string)
void	set_range (long, long)

↠ ARDOUR:Slavable

C‡: std::shared_ptr< ARDOUR::Slavable >, std::weak_ptr< ARDOUR::Slavable >

Methods
void	assign (VCA)
bool	assigned_to (VCAManager, VCA)
bool	isnil ()
VCAVector	masters (VCAManager)
void	unassign (VCA)

↠ ARDOUR:SlavableAutomationControl

C‡: std::shared_ptr< ARDOUR::SlavableAutomationControl >, std::weak_ptr< ARDOUR::SlavableAutomationControl >

is-a: ARDOUR:AutomationControl

Base class for objects with saveable and undoable state

Methods
void	add_master (AutomationControl)
void	clear_masters ()
int	get_boolean_masters ()
double	get_masters_value ()
bool	isnil ()
void	remove_master (AutomationControl)
bool	slaved ()
bool	slaved_to (AutomationControl)

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:SoloControl

C‡: std::shared_ptr< ARDOUR::SoloControl >, std::weak_ptr< ARDOUR::SoloControl >

is-a: ARDOUR:SlavableAutomationControl

Base class for objects with saveable and undoable state

Methods
bool	can_solo ()
bool	isnil ()
bool	self_soloed ()
bool	soloed ()

Inherited from ARDOUR:SlavableAutomationControl

Methods
void	add_master (AutomationControl)
void	clear_masters ()
int	get_boolean_masters ()
double	get_masters_value ()
void	remove_master (AutomationControl)
bool	slaved ()
bool	slaved_to (AutomationControl)

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:SoloIsolateControl

C‡: std::shared_ptr< ARDOUR::SoloIsolateControl >, std::weak_ptr< ARDOUR::SoloIsolateControl >

is-a: ARDOUR:SlavableAutomationControl

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
bool	self_solo_isolated ()
bool	solo_isolated ()

Inherited from ARDOUR:SlavableAutomationControl

Methods
void	add_master (AutomationControl)
void	clear_masters ()
int	get_boolean_masters ()
double	get_masters_value ()
void	remove_master (AutomationControl)
bool	slaved ()
bool	slaved_to (AutomationControl)

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:SoloSafeControl

C‡: std::shared_ptr< ARDOUR::SoloSafeControl >, std::weak_ptr< ARDOUR::SoloSafeControl >

is-a: ARDOUR:SlavableAutomationControl

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
bool	solo_safe ()

Inherited from ARDOUR:SlavableAutomationControl

Methods
void	add_master (AutomationControl)
void	clear_masters ()
int	get_boolean_masters ()
double	get_masters_value ()
void	remove_master (AutomationControl)
bool	slaved ()
bool	slaved_to (AutomationControl)

Inherited from ARDOUR:AutomationControl

Methods
[AutomationList](#A RDOUR:AutomationList)	[a list]{.functionname}[ ()]{.functionargs}
[AutoStat e](#ARDOUR.AutoState)	[automation_s tate]{.functionname}[ ()]{.functionargs}
[Paramet erDescriptor](#ARDOUR :ParameterDescriptor)	[ desc]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[double]{.em}	[l ower]{.functionname}[ ()]{.functionargs}
[double]{.em}	[no rmal]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_automation_s tate]{.functionname}[ ([Auto State](#ARDOUR.AutoSt ate))]{.functionargs}
[void]{.em}	[set_v alue]{.functionname}[ ([double]{.em}, [ GroupControlDispositi on](#PBD.Controllable .GroupControlDisposit ion))]{.functionargs}
	::: dox Set `internal' value All derived classes must implement this. Basic derived classes will ignore group_override but more sophisticated children, notably those that proxy the value setting logic via an object that is aware of group relationships between this control and others, will find it useful. value : raw numeric value to set group_override : if and how to propagate value to grouped controls ::
[void]{.em}	[start_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[stop_t ouch]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[tog gled]{.functionname}[ ()]{.functionargs}
[double]{.em}	[u pper]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[writ able]{.functionname}[ ()]{.functionargs}
Cast
[Cont rol](#Evoral:Control)	[to_ ctrl]{.functionname}[ ()]{.functionargs}
[SlavableAutomationC ontrol](#ARDOUR:Slava bleAutomationControl)	[to_slav able]{.functionname}[ ()]{.functionargs}

Inherited from PBD:Controllable

Methods
void	dump_registry ()
std::string	name ()
ControllableSet	registered_controllables ()
Cast
AutomationControl	to_automationcontrol ()
MPGainControl	to_mpgain ()
MPToggleControl	to_mptoggle ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:Source

C‡: std::shared_ptr< ARDOUR::Source >, std::weak_ptr< ARDOUR::Source >

is-a: ARDOUR:SessionObjectPtr

A named object associated with a Session. Objects derived from this class are expected to be destroyed before the session calls drop_references().

Methods
std::string	ancestor_name ()
bool	can_be_analysed ()
XrunPositions	captured_xruns ()
bool	empty ()
bool	has_been_analysed ()
bool	isnil ()
timepos_t	length ()
timepos_t	natural_position ()
timepos_t	timeline_position ()
long	timestamp ()
int	use_count ()
bool	used ()
bool	writable ()
Cast
AudioSource	to_audiosource ()
FileSource	to_filesource ()
MidiSource	to_midisource ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:SourceList

C‡: std::vector<std::shared_ptr<ARDOUR::Source> >

Constructor
ℂ	ARDOUR.SourceList ()
ℂ	ARDOUR.SourceList ()
Methods
LuaTable	add (LuaTable {Source})
Source	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (Source)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

↠ ARDOUR:Stripable

C‡: std::shared_ptr< ARDOUR::Stripable >, std::weak_ptr< ARDOUR::Stripable >

is-a: ARDOUR:SessionObjectPtr

A named object associated with a Session. Objects derived from this class are expected to be destroyed before the session calls drop_references().

Methods
unsigned int	eq_band_cnt ()
std::string	eq_band_name (unsigned int)
GainControl	gain_control ()
bool	is_auditioner ()
bool	is_hidden ()
bool	is_master ()
bool	is_monitor ()
bool	is_private_route ()
bool	is_selected ()
bool	is_surround_master ()
bool	isnil ()
AutomationControl	mapped_control (WellKnownCtrl, unsigned int)
ReadOnlyControl	mapped_output (WellKnownData)
AutomationControl	master_send_enable_controllable ()
MonitorProcessor	monitor_control ()
MuteControl	mute_control ()
AutomationControl	pan_azimuth_control ()
AutomationControl	pan_elevation_control ()
AutomationControl	pan_frontback_control ()
AutomationControl	pan_lfe_control ()
AutomationControl	pan_width_control ()
PhaseControl	phase_control ()
PresentationInfo	presentation_info_ptr ()
AutomationControl	rec_enable_control ()
AutomationControl	rec_safe_control ()
AutomationControl	send_enable_controllable (unsigned int)
AutomationControl	send_level_controllable (unsigned int, bool)
std::string	send_name (unsigned int)
AutomationControl	send_pan_azimuth_controllable (unsigned int)
AutomationControl	send_pan_azimuth_enable_controllable (unsigned int)
void	set_presentation_order (unsigned int)
bool	slaved ()
bool	slaved_to (VCA)
SoloControl	solo_control ()
SoloIsolateControl	solo_isolate_control ()
SoloSafeControl	solo_safe_control ()
GainControl	trim_control ()
Cast
Automatable	to_automatable ()
Route	to_route ()
Slavable	to_slavable ()
VCA	to_vca ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:StripableList

C‡: std::list<std::shared_ptr<ARDOUR::Stripable> >

Constructor
ℂ	ARDOUR.StripableList ()
Methods
Stripable	back ()
bool	empty ()
Stripable	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

↠ ARDOUR:SurroundPannable

C‡: std::shared_ptr< ARDOUR::SurroundPannable >, std::weak_ptr< ARDOUR::SurroundPannable >

is-a: ARDOUR:Automatable

Base class for objects with saveable and undoable state

Methods
bool	isnil ()
Data Members
ARDOUR:AutomationControl	binaural_render_mode
ARDOUR:AutomationControl	pan_pos_x
ARDOUR:AutomationControl	pan_pos_y
ARDOUR:AutomationControl	pan_pos_z
ARDOUR:AutomationControl	pan_size
ARDOUR:AutomationControl	pan_snap
ARDOUR:AutomationControl	sur_elevation_enable
ARDOUR:AutomationControl	sur_ramp
ARDOUR:AutomationControl	sur_zones

Inherited from ARDOUR:Automatable

Methods
[ParameterList](# ARDOUR:ParameterList)	[all_automatable_pa rams]{.functionname}[ ()]{.functionargs}
	::: dox API for Lua binding ::
[Aut omationControl](#ARDO UR:AutomationControl)	[automation_con trol]{.functionname}[ ([Parameter ](#Evoral:Parameter), [bool]{ .em})]{.functionargs}
Cast
[Slavab le](#ARDOUR:Slavable)	[to_slav able]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:SurroundReturn

C‡: std::shared_ptr< ARDOUR::SurroundReturn >, std::weak_ptr< ARDOUR::SurroundReturn >

is-a: ARDOUR:Processor

Base class for objects with saveable and undoable state

Methods
bool	have_au_renderer ()
float	integrated_loudness ()
bool	isnil ()
bool	load_au_preset (unsigned long)
float	max_dbtp ()
float	max_momentary ()
float	momentary ()
unsigned long	n_channels ()
Controllable	output_format_controllable ()
bool	set_au_param (unsigned long, float)
void	set_bed_mix (bool, std::string, IntArray)
void	set_ffoa (float)
void	set_sync_and_align (bool)
void	set_with_all_metadata (bool)
unsigned long	total_n_channels (bool)

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:SurroundSend

C‡: std::shared_ptr< ARDOUR::SurroundSend >, std::weak_ptr< ARDOUR::SurroundSend >

is-a: ARDOUR:Processor

Internal Abstraction for Sends (and MixbusSends)

Methods
GainControl	gain_control ()
long	get_delay_in ()
long	get_delay_out ()
bool	isnil ()
unsigned int	n_pannables ()
SurroundPannable	pannable (unsigned long)

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:TimelineRange

C‡: ARDOUR::TimelineRange

Constructor
ℂ	ARDOUR.TimelineRange (timepos_t, timepos_t, unsigned int)
Methods
timepos_t	_end ()
bool	equal (TimelineRange)
timecnt_t	length ()
timepos_t	start ()
Data Members
unsigned int	id

∁ ARDOUR:TimelineRangeList

C‡: std::list<ARDOUR::TimelineRange >

Constructor
ℂ	ARDOUR.TimelineRangeList ()
Methods
LuaTable	add (LuaTable {TimelineRange})
TimelineRange	back ()
void	clear ()
bool	empty ()
TimelineRange	front ()
LuaIter	iter ()
void	push_back (TimelineRange)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

↠ ARDOUR:Track

C‡: std::shared_ptr< ARDOUR::Track >, std::weak_ptr< ARDOUR::Track >

is-a: ARDOUR:Route

Constructor
ℵ	[ARDOUR.T rack]{.functionname}[ ()]{.functionargs}
Methods
[Re gion](#ARDOUR:Region)	[bo unce]{.functionname}[ ([I nterThreadInfo&](#ARD OUR:InterThreadInfo), [std::string]{ .em})]{.functionargs}
[Re gion](#ARDOUR:Region)	[bounce_r ange]{.functionname}[ ([long]{.em}, [long]{.em}, [I nterThreadInfo&](#ARD OUR:InterThreadInfo), [Processor ](#ARDOUR:Processor), [bool]{.em}, [std::string]{.em}, [bool]{ .em})]{.functionargs}
[bool]{.em}	[bounce able]{.functionname}[ ([Processor ](#ARDOUR:Processor), [bool]{ .em})]{.functionargs}
	::: dox Test if the track can be bounced with the given settings. If sends/inserts/returns are present in the signal path or the given track has no audio outputs bouncing is not possible. endpoint : the processor to tap the signal off (or nil for the top) include_endpoint : include the given processor in the bounced audio. ::: result-discussion [Re turns]{.word-returns} true if the track can be bounced, or false otherwise. ::: ::
[bool]{.em}	[can_re cord]{.functionname}[ ()]{.functionargs}
[int]{.em}	[find_and_use_play list]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [ID](#PBD :ID))]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[Playli st](#ARDOUR:Playlist)	[play list]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[set_ name]{.functionname}[ ([std::string]{ .em})]{.functionargs}
[int]{.em}	[use_copy_play list]{.functionname}[ ()]{.functionargs}
[int]{.em}	[use_new_play list]{.functionname}[ ([Da taType](#ARDOUR:DataT ype))]{.functionargs}
[int]{.em}	[use_play list]{.functionname}[ ([DataTyp e](#ARDOUR:DataType), [Playlis t](#ARDOUR:Playlist), [bool]{ .em})]{.functionargs}
Cast
[AudioTrack ](#ARDOUR:AudioTrack)	[to_audio_t rack]{.functionname}[ ()]{.functionargs}
[MidiTrac k](#ARDOUR:MidiTrack)	[to_midi_t rack]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Route

Methods
[bool]{.em}	[ac tive]{.functionname}[ ()]{.functionargs}
[int]{.em}	[add_aux_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox Add an aux send to a route. route : route to send to. before : Processor to insert before, or 0 to insert at the end. ::
[int]{.em}	[add_foldback_ send]{.functionname}[ ([R oute](#ARDOUR:Route), [bool]{ .em})]{.functionargs}
[int]{.em}	[add_processor_by_i ndex]{.functionname}[ ([Processor ](#ARDOUR:Processor), [int]{.em}, [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[bool]{.em}	[add_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[Amp](#ARDOUR:Amp)	[amp]{.functionname}[ ()]{.functionargs}
[void]{.em}	[clear_stripa bles]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[com ment]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[customize_plugin_in sert]{.functionname}[ ([Processor ](#ARDOUR:Processor), [unsigned int]{.em}, [ChanCount ](#ARDOUR:ChanCount), [Chan Count](#ARDOUR:ChanCo unt))]{.functionargs}
[DataTy pe](#ARDOUR:DataType)	[data_ type]{.functionname}[ ()]{.functionargs}
[Stripabl e](#ARDOUR:Stripable)	[first_selected_strip able]{.functionname}[ ()]{.functionargs}
[IO](#ARDOUR:IO)	[i nput]{.functionname}[ ()]{.functionargs}
[Delive ry](#ARDOUR:Delivery)	[main_ outs]{.functionname}[ ()]{.functionargs}
[MonitorControl](#A RDOUR:MonitorControl)	[monitoring_con trol]{.functionname}[ ()]{.functionargs}
[MonitorState]( #ARDOUR.MonitorState)	[monitoring_s tate]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[m uted]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_in puts]{.functionname}[ ()]{.functionargs}
[ChanCoun t](#ARDOUR:ChanCount)	[n_out puts]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_pl ugin]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_proce ssor]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[Processo r](#ARDOUR:Processor)	[nth_ send]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
[IO](#ARDOUR:IO)	[ou tput]{.functionname}[ ()]{.functionargs}
[PannerShell] (#ARDOUR:PannerShell)	[panner_s hell]{.functionname}[ ()]{.functionargs}
[PeakMete r](#ARDOUR:PeakMeter)	[peak_m eter]{.functionname}[ ()]{.functionargs}
[long]{.em}	[playback_lat ency]{.functionname}[ ([bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processo rStreams](#ARDOUR:Rou te:ProcessorStreams), [bool]{ .em})]{.functionargs}
[int]{.em}	[remove_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[remove_sidec hain]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
[int]{.em}	[reorder_proces sors]{.functionname}[ ([ProcessorList](#A RDOUR:ProcessorList), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[int]{.em}	[replace_proce ssor]{.functionname}[ ([Processor ](#ARDOUR:Processor), [Processor ](#ARDOUR:Processor), [Pro cessorStreams](#ARDOU R:Route:ProcessorStre ams))]{.functionargs}
[bool]{.em}	[reset_plugin_in sert]{.functionname}[ ([Proc essor](#ARDOUR:Proces sor))]{.functionargs}
	::: dox reset plugin-insert configuration to default, disable customizations. This is equivalent to calling customize_plugin_ins ert (proc, 0, unused) proc : Processor to reset ::: result-discussion [Re turns]{.word-returns} true if successful ::: ::
[int]{.em}	[save_as_temp late]{.functionname}[ ([std::string]{.em}, [std::string]{.em}, [std::string]{ .em})]{.functionargs}
[void]{.em}	[select_next_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[select_prev_strip able]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[set_ac tive]{.functionname}[ ([bool]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_com ment]{.functionname}[ ([std::string]{.em}, [void*]{ .em})]{.functionargs}
[void]{.em}	[set_meter_p oint]{.functionname}[ ([MeterP oint](#ARDOUR.MeterPo int))]{.functionargs}
[bool]{.em}	[set_stric t_io]{.functionname}[ ([bool]{ .em})]{.functionargs}
[long]{.em}	[signal_lat ency]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[so loed]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[stric t_io]{.functionname}[ ()]{.functionargs}
[SurroundReturn](#A RDOUR:SurroundReturn)	[surround_re turn]{.functionname}[ ()]{.functionargs}
[SurroundSend]( #ARDOUR:SurroundSend)	[surround_ send]{.functionname}[ ()]{.functionargs}
[Processo r](#ARDOUR:Processor)	[the_instru ment]{.functionname}[ ()]{.functionargs}
	::: dox Return the first processor that accepts has at least one MIDI input and at least one audio output. In the vast majority of cases, this will be "the instrument". This does not preclude other MIDI->audio processors later in the processing chain, but that would be a special case not covered by this utility function. ::
[Amp](#ARDOUR:Amp)	[ trim]{.functionname}[ ()]{.functionargs}
Cast
[ Track](#ARDOUR:Track)	[to_t rack]{.functionname}[ ()]{.functionargs}

Inherited from ARDOUR:Stripable

Methods
unsigned int	eq_band_cnt ()
std::string	eq_band_name (unsigned int)
GainControl	gain_control ()
bool	is_auditioner ()
bool	is_hidden ()
bool	is_master ()
bool	is_monitor ()
bool	is_private_route ()
bool	is_selected ()
bool	is_surround_master ()
AutomationControl	mapped_control (WellKnownCtrl, unsigned int)
ReadOnlyControl	mapped_output (WellKnownData)
AutomationControl	master_send_enable_controllable ()
MonitorProcessor	monitor_control ()
MuteControl	mute_control ()
AutomationControl	pan_azimuth_control ()
AutomationControl	pan_elevation_control ()
AutomationControl	pan_frontback_control ()
AutomationControl	pan_lfe_control ()
AutomationControl	pan_width_control ()
PhaseControl	phase_control ()
PresentationInfo	presentation_info_ptr ()
AutomationControl	rec_enable_control ()
AutomationControl	rec_safe_control ()
AutomationControl	send_enable_controllable (unsigned int)
AutomationControl	send_level_controllable (unsigned int, bool)
std::string	send_name (unsigned int)
AutomationControl	send_pan_azimuth_controllable (unsigned int)
AutomationControl	send_pan_azimuth_enable_controllable (unsigned int)
void	set_presentation_order (unsigned int)
bool	slaved ()
bool	slaved_to (VCA)
SoloControl	solo_control ()
SoloIsolateControl	solo_isolate_control ()
SoloSafeControl	solo_safe_control ()
GainControl	trim_control ()
Cast
Automatable	to_automatable ()
Route	to_route ()
Slavable	to_slavable ()
VCA	to_vca ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:UnknownProcessor

C‡: std::shared_ptr< ARDOUR::UnknownProcessor >, std::weak_ptr< ARDOUR::UnknownProcessor >

is-a: ARDOUR:Processor

Methods
bool	isnil ()

Inherited from ARDOUR:Processor

Methods
void	activate ()
bool	active ()
long	capture_offset ()
void	deactivate ()
std::string	display_name ()
bool	display_to_user ()
long	input_latency ()
ChanCount	input_streams ()
long	output_latency ()
ChanCount	output_streams ()
long	playback_offset ()
long	signal_latency ()
Cast
Amp	to_amp ()
Automatable	to_automatable ()
DelayLine	to_delayline ()
DiskIOProcessor	to_diskioprocessor ()
DiskReader	to_diskreader ()
DiskWriter	to_diskwriter ()
PluginInsert	to_insert ()
InternalSend	to_internalsend ()
IOProcessor	to_ioprocessor ()
Latent	to_latent ()
PeakMeter	to_meter ()
MonitorProcessor	to_monitorprocessor ()
PeakMeter	to_peakmeter ()
PluginInsert	to_plugininsert ()
PolarityProcessor	to_polarityprocessor ()
Send	to_send ()
SideChain	to_sidechain ()
SurroundSend	to_surroundsend ()
UnknownProcessor	to_unknownprocessor ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

↠ ARDOUR:UserBundle

C‡: std::shared_ptr< ARDOUR::UserBundle >, std::weak_ptr< ARDOUR::UserBundle >

is-a: ARDOUR:Bundle

A set of `channels’, each of which is associated with 0 or more ports. Each channel has a name which can be anything useful, and a data type. Intended for grouping things like, for example, a buss’ outputs. `Channel’ is a rather overloaded term but I can’t think of a better one right now.

Methods
bool	isnil ()

Inherited from ARDOUR:Bundle

Methods
[std::string]{.em}	[channel_ name]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox ch : Channel. ::: result-discussion [Re turns]{.word-returns} Channel name. ::: ::
[unsigned int]{.em}	[n_t otal]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Bundle name ::: ::
[ChanCoun t](#ARDOUR:ChanCount)	[nchan nels]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} Number of channels that this Bundle has ::: ::
[bool]{.em}	[ports_are_in puts]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[ports_are_out puts]{.functionname}[ ()]{.functionargs}
Cast
[UserBundle ](#ARDOUR:UserBundle)	[to_userbu ndle]{.functionname}[ ()]{.functionargs}

↠ ARDOUR:VCA

C‡: std::shared_ptr< ARDOUR::VCA >, std::weak_ptr< ARDOUR::VCA >

is-a: ARDOUR:Stripable

Base class for objects with saveable and undoable state

Methods
std::string	full_name ()
GainControl	gain_control ()
bool	isnil ()
MuteControl	mute_control ()
int	number ()
SoloControl	solo_control ()

Inherited from ARDOUR:Stripable

Methods
unsigned int	eq_band_cnt ()
std::string	eq_band_name (unsigned int)
bool	is_auditioner ()
bool	is_hidden ()
bool	is_master ()
bool	is_monitor ()
bool	is_private_route ()
bool	is_selected ()
bool	is_surround_master ()
AutomationControl	mapped_control (WellKnownCtrl, unsigned int)
ReadOnlyControl	mapped_output (WellKnownData)
AutomationControl	master_send_enable_controllable ()
MonitorProcessor	monitor_control ()
AutomationControl	pan_azimuth_control ()
AutomationControl	pan_elevation_control ()
AutomationControl	pan_frontback_control ()
AutomationControl	pan_lfe_control ()
AutomationControl	pan_width_control ()
PhaseControl	phase_control ()
PresentationInfo	presentation_info_ptr ()
AutomationControl	rec_enable_control ()
AutomationControl	rec_safe_control ()
AutomationControl	send_enable_controllable (unsigned int)
AutomationControl	send_level_controllable (unsigned int, bool)
std::string	send_name (unsigned int)
AutomationControl	send_pan_azimuth_controllable (unsigned int)
AutomationControl	send_pan_azimuth_enable_controllable (unsigned int)
void	set_presentation_order (unsigned int)
bool	slaved ()
bool	slaved_to (VCA)
SoloIsolateControl	solo_isolate_control ()
SoloSafeControl	solo_safe_control ()
GainControl	trim_control ()
Cast
Automatable	to_automatable ()
Route	to_route ()
Slavable	to_slavable ()
VCA	to_vca ()

Inherited from ARDOUR:SessionObjectPtr

Methods
std::string	name ()
Cast
Stateful	to_stateful ()
StatefulDestructible	to_statefuldestructible ()

∁ ARDOUR:VCAList

C‡: std::list<std::shared_ptr<ARDOUR::VCA> >

Constructor
ℂ	ARDOUR.VCAList ()
Methods
VCA	back ()
bool	empty ()
VCA	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:VCAManager

C‡: ARDOUR::VCAManager

is-a: PBD:StatefulDestructible

Base class for objects with saveable and undoable state with destruction notification

Methods
VCAList	create_vca (unsigned int, std::string)
unsigned long	n_vcas ()
void	remove_vca (VCA)
VCA	vca_by_name (std::string)
VCA	vca_by_number (int)
VCAList	vcas ()

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ ARDOUR:VCAVector

C‡: std::vector<std::shared_ptr<ARDOUR::VCA> >

Constructor
ℂ	ARDOUR.VCAVector ()
Methods
VCA	at (unsigned long)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:WeakAudioSourceList

C‡: std::list<std::weak_ptr<ARDOUR::AudioSource> >

Constructor
ℂ	ARDOUR.WeakAudioSourceList ()
Methods
AudioSource	back ()
bool	empty ()
AudioSource	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:WeakRouteList

C‡: std::list<std::weak_ptr<ARDOUR::Route> >

Constructor
ℂ	ARDOUR.WeakRouteList ()
Methods
Route	back ()
bool	empty ()
Route	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:WeakSourceList

C‡: std::list<std::weak_ptr<ARDOUR::Source> >

Constructor
ℂ	ARDOUR.WeakSourceList ()
Methods
Source	back ()
bool	empty ()
Source	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ARDOUR:XrunPositions

C‡: std::vector<long >

Constructor
ℂ	ARDOUR.XrunPositions ()
ℂ	ARDOUR.XrunPositions ()
Methods
LuaTable	add (LuaTable {long})
long	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (long)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

ℕ ArdourUI

Methods
LuaTable	actionlist ()
UIConfiguration	config ()
std::string	http_get (std::string)
void	mixer_screenshot (std::string)
ProcessorVector	processor_selection ()
unsigned int	translate_order (InsertAt)

∁ ArdourUI:ARDOUR::AutomationListList

C‡: std::list<std::shared_ptr<ARDOUR::AutomationList> >

Constructor
ℂ	ArdourUI.ARDOUR…AutomationListList ()
Methods
LuaTable	add (LuaTable {AutomationList})
AutomationList	back ()
void	clear ()
bool	empty ()
AutomationList	front ()
LuaIter	iter ()
void	push_back (AutomationList)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ArdourUI:ArdourMarker

C‡: ArdourMarker

Location Marker

Editor ruler representation of a location marker or range on the timeline.

Methods
std::string	name ()
timepos_t	position ()
Type	_type ()

∁ ArdourUI:ArdourMarkerList

C‡: std::list<ArdourMarker* >

Constructor
ℂ	ArdourUI.ArdourMarkerList ()
Methods
ArdourMarker	back ()
void	clear ()
bool	empty ()
ArdourMarker	front ()
LuaIter	iter ()
.…	push_back (–lua–)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∅ ArdourUI:AutomationSelection

C‡: AutomationSelection

is-a: ArdourUI:ARDOUR::AutomationListList

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from ArdourUI:ARDOUR::AutomationListList

Constructor
ℂ	ArdourUI.ARDOUR…AutomationListList ()
Methods
LuaTable	add (LuaTable {AutomationList})
AutomationList	back ()
void	clear ()
bool	empty ()
AutomationList	front ()
LuaIter	iter ()
void	push_back (AutomationList)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∅ ArdourUI:AxisView

C‡: AxisView

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∅ ArdourUI:ControlPoint

C‡: ControlPoint

is-a: ArdourUI:Selectable

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∁ ArdourUI:ControlPointList

C‡: std::list<ControlPoint* >

Constructor
ℂ	ArdourUI.ControlPointList ()
Methods
ControlPoint	back ()
void	clear ()
bool	empty ()
ControlPoint	front ()
LuaIter	iter ()
.…	push_back (–lua–)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ArdourUI:EditingContext

C‡: EditingContext

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

Methods
[TrackViewList](#Ar dourUI:TrackViewList)	[axis_views_from_ro utes]{.functionname}[ ([RouteListP tr](#ARDOUR:RouteList Ptr))]{.functionargs}
[MouseMode ](#Editing.MouseMode)	[current_mouse_ mode]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} The current mouse mode (gain, object, range, timefx etc.) (defined in editing_syms.inc.h) ::: ::
*LuaTable*([Locatio n](#ARDOUR:Location), ...)	[ find_location_from_ma rker]{.functionname}[ ([ArdourMarker](#Ar dourUI:ArdourMarker), [bool&]{ .em})]{.functionargs}
[ArdourMarker](#A rdourUI:ArdourMarker)	[fin d_marker_from_locatio n_id]{.functionname}[ ([ID](#PBD:ID), [bool]{ .em})]{.functionargs}
[long]{.em}	[get_current_ zoom]{.functionname}[ ()]{.functionargs}
[Selection] (#ArdourUI:Selection)	[get_cut_bu ffer]{.functionname}[ ()]{.functionargs}
*LuaTable*([Bea ts](#Temporal:Beats), ...)	[get_draw_length_as_b eats]{.functionname}[ ([bool&]{.em}, [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[int]{.em}	[get_grid_beat_divis ions]{.functionname}[ ([Gri dType](#Editing.GridT ype))]{.functionargs}
*LuaTable*([Bea ts](#Temporal:Beats), ...)	[get_grid_type_as_b eats]{.functionname}[ ([bool&]{.em}, [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
*L uaTable*([timecnt_t]( #Temporal:timecnt_t), ...)	[get_nudge_dist ance]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timecnt _t&](#Temporal:timecn t_t))]{.functionargs}
[Selection] (#ArdourUI:Selection)	[get_selec tion]{.functionname}[ ()]{.functionargs}
[StripableTime AxisView](#ArdourUI:S tripableTimeAxisView)	[get_ stripable_time_axis_b y_id]{.functionname}[ ([ID](#PBD :ID))]{.functionargs}
[double]{.em}	[get_y_or igin]{.functionname}[ ()]{.functionargs}
[GridTyp e](#Editing.GridType)	[grid_ type]{.functionname}[ ()]{.functionargs}
[long]{.em}	[pixel_to_sa mple]{.functionname}[ ([double]{ .em})]{.functionargs}
[void]{.em}	[ redo]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox Redo some transactions. n : Number of transaction to redo. ::
[void]{.em}	[reset_x_or igin]{.functionname}[ ([long]{ .em})]{.functionargs}
	::: dox Queue up a change to the Editor viewport x origin. sample : New x origin. ::
[void]{.em}	[reset_y_or igin]{.functionname}[ ([double]{ .em})]{.functionargs}
[void]{.em}	[reset_ zoom]{.functionname}[ ([long]{ .em})]{.functionargs}
[double]{.em}	[sample_to_p ixel]{.functionname}[ ([long]{ .em})]{.functionargs}
[void]{.em}	[set_mouse_ mode]{.functionname}[ ([MouseMode] (#Editing.MouseMode), [bool]{ .em})]{.functionargs}
	::: dox Set the mouse mode (gain, object, range, timefx etc.) force : Perform the effects of the change even if no change is required (ie even if the current mouse mode is equal to m) m : Mouse mode (defined in editing_syms.inc.h) ::
[void]{.em}	[set_snap_ mode]{.functionname}[ ([Sna pMode](#Editing.SnapM ode))]{.functionargs}
[void]{.em}	[set_zoom_f ocus]{.functionname}[ ([ZoomF ocus](#Editing.ZoomFo cus))]{.functionargs}
[SnapMod e](#Editing.SnapMode)	[snap_ mode]{.functionname}[ ()]{.functionargs}
[void]{.em}	[ undo]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox Undo some transactions. n : Number of transactions to undo. ::
[ZoomFocus ](#Editing.ZoomFocus)	[zoom_f ocus]{.functionname}[ ()]{.functionargs}

∁ ArdourUI:Editor

C‡: PublicEditor

is-a: ArdourUI:EditingContext

Methods
[void]{.em}	[access_ac tion]{.functionname}[ ([std::string]{.em}, [std::string]{ .em})]{.functionargs}
[void]{.em}	[add_loca tion_from_playhead_cu rsor]{.functionname}[ ()]{.functionargs}
[void]{.em}	[add_location_ mark]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [Flags](#AR DOUR.Location.Flags), [int]{ .em})]{.functionargs}
[void]{.em}	[center_sc reen]{.functionname}[ ([long]{ .em})]{.functionargs}
[void]{.em}	[clear_grouped_playl ists]{.functionname}[ ([Ro uteUI](#ArdourUI:Rout eUI))]{.functionargs}
[void]{.em}	[clear_play list]{.functionname}[ ([Pl aylist](#ARDOUR:Playl ist))]{.functionargs}
[void]{.em}	[consider_auditio ning]{.functionname}[ ([Region](#ARDOUR:Reg ion))]{.functionargs}
	::: dox Possibly start the audition of a region. If r is 0, or not an AudioRegion any current audition is cancelled. If we are currently auditioning r , the audition will be cancelled. Otherwise an audition of r will start. r : Region to consider auditioning ::
[ Route](#ARDOUR:Route)	[current_mixer_strip able]{.functionname}[ ()]{.functionargs}
[long]{.em}	[current_page_sam ples]{.functionname}[ ()]{.functionargs}
[void]{.em}	[deselect _all]{.functionname}[ ()]{.functionargs}
*LuaTable*(...)	[do_e mbed]{.functionname}[ ([StringVect or](#C:StringVector), [Impor tDisposition](#Editin g.ImportDisposition), [ImportMode]( #Editing.ImportMode), [timepos_t&]( #Temporal:timepos_t), [PluginInfo] (#ARDOUR:PluginInfo), [Track](#ARDOUR:Tr ack))]{.functionargs}
*LuaTable*(...)	[do_im port]{.functionname}[ ([StringVect or](#C:StringVector), [Impor tDisposition](#Editin g.ImportDisposition), [ImportMode]( #Editing.ImportMode), [SrcQuality] (#ARDOUR.SrcQuality), [MidiTrac kNameSource](#ARDOUR. MidiTrackNameSource), [MidiTempoMapDisp osition](#ARDOUR.Midi TempoMapDisposition), [timepos_t&]( #Temporal:timepos_t), [PluginInfo] (#ARDOUR:PluginInfo), [T rack](#ARDOUR:Track), [bool]{ .em})]{.functionargs}
[bool]{.em}	[dragging_play head]{.functionname}[ ()]{.functionargs}
[MouseMode ](#Editing.MouseMode)	[effective_mouse_ mode]{.functionname}[ ()]{.functionargs}
[void]{.em}	[export_a udio]{.functionname}[ ()]{.functionargs}
	::: dox Open main export dialog ::
[void]{.em}	[export_r ange]{.functionname}[ ()]{.functionargs}
	::: dox Open export dialog with current range preselected ::
[void]{.em}	[export_selec tion]{.functionname}[ ()]{.functionargs}
	::: dox Open export dialog with current selection preselected ::
[void]{.em}	[fit_selec tion]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[follow_play head]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if the editor is following the playhead ::: ::
[timecnt_t] (#Temporal:timecnt_t)	[get_paste_of fset]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [unsigned int]{.em}, [timecn t_t](#Temporal:timecn t_t))]{.functionargs}
*LuaTable*(...)	[get_pointer_posi tion]{.functionname}[ ([double&]{.em}, [double&]{ .em})]{.functionargs}
*L uaTable*([bool]{.em}, ...)	[get_selection_ext ents]{.functionname}[ ([timepos_t&]( #Temporal:timepos_t), [timepos _t&](#Temporal:timepo s_t))]{.functionargs}
[bool]{.em}	[get_smart_ mode]{.functionname}[ ()]{.functionargs}
[TrackViewList](#Ar dourUI:TrackViewList)	[get_track_v iews]{.functionname}[ ()]{.functionargs}
[int]{.em}	[get_videotl_bar_he ight]{.functionname}[ ()]{.functionargs}
[void]{.em}	[goto_nth_ma rker]{.functionname}[ ([int]{ .em})]{.functionargs}
[void]{.em}	[hide_track_in_dis play]{.functionname}[ ([TimeAxisView](#Ar dourUI:TimeAxisView), [bool]{ .em})]{.functionargs}
[long]{.em}	[leftmost_sa mple]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if the playhead is currently being dragged, otherwise false ::: ::
[void]{.em}	[maximise_editing_s pace]{.functionname}[ ()]{.functionargs}
[void]{.em}	[maybe _locate_with_edit_pre roll]{.functionname}[ ([long]{ .em})]{.functionargs}
[void]{.em}	[mouse_add_new_ma rker]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [Flags](#AR DOUR.Location.Flags), [int]{ .em})]{.functionargs}
[void]{.em}	[new _playlists_for_all_tr acks]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[new_p laylists_for_armed_tr acks]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[new_pla ylists_for_grouped_tr acks]{.functionname}[ ([RouteUI ](#ArdourUI:RouteUI), [bool]{ .em})]{.functionargs}
[void]{.em}	[new_play lists_for_selected_tr acks]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[ new_region_from_selec tion]{.functionname}[ ()]{.functionargs}
[void]{.em}	[ove rride_visible_track_c ount]{.functionname}[ ()]{.functionargs}
[void]{.em}	[play_selec tion]{.functionname}[ ()]{.functionargs}
[void]{.em}	[play_with_pre roll]{.functionname}[ ()]{.functionargs}
[void]{.em}	[quick_ex port]{.functionname}[ ()]{.functionargs}
	::: dox Open Simple Export Dialog ::
[RegionView]( #ArdourUI:RegionView)	[regionview_from_re gion]{.functionname}[ ([Region](#ARDOUR:Reg ion))]{.functionargs}
[void]{.em}	[remove_last_cap ture]{.functionname}[ ()]{.functionargs}
[void]{.em}	[remove_lo cation_at_playhead_cu rsor]{.functionname}[ ()]{.functionargs}
[void]{.em}	[remove_tr acks]{.functionname}[ ()]{.functionargs}
[void]{.em}	[restore_editing_s pace]{.functionname}[ ()]{.functionargs}
[Route TimeAxisView](#Ardour UI:RouteTimeAxisView)	[rtav_from_r oute]{.functionname}[ ([Route](#ARDOUR:Ro ute))]{.functionargs}
[bool]{.em}	[scroll_down_one_t rack]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[scroll_tracks_down_ line]{.functionname}[ ()]{.functionargs}
[void]{.em}	[scroll_tracks_up_ line]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[scroll_up_one_t rack]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[select_all_tr acks]{.functionname}[ ()]{.functionargs}
[void]{.em}	[select_all_visible_l anes]{.functionname}[ ()]{.functionargs}
[void]{.em}	[separ ate_region_from_selec tion]{.functionname}[ ()]{.functionargs}
[void]{.em}	[set_follow_play head]{.functionname}[ ([bool]{.em}, [bool]{ .em})]{.functionargs}
	::: dox Set whether the editor should follow the playhead. yn : true to follow playhead, otherwise false. catch_up : true to reset the editor view to show the playhead (if yn == true), otherwise false. ::
[void]{.em}	[set_loop_r ange]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepos_t]( #Temporal:timepos_t), [std::string]{ .em})]{.functionargs}
[void]{.em}	[set_punch_r ange]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepos_t]( #Temporal:timepos_t), [std::string]{ .em})]{.functionargs}
[void]{.em}	[set_selec tion]{.functionname}[ ([SelectionList](#Ard ourUI:SelectionList), [S electionOperation](#A RDOUR.SelectionOperat ion))]{.functionargs}
[void]{.em}	[set_stationary_play head]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[set_toggleac tion]{.functionname}[ ([std::string]{.em}, [std::string]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[ set_video_timeline_he ight]{.functionname}[ ([int]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[set_visible_track_c ount]{.functionname}[ ([int]{ .em})]{.functionargs}
[void]{.em}	[show_track_in_dis play]{.functionname}[ ([TimeAxisView](#Ar dourUI:TimeAxisView), [bool]{ .em})]{.functionargs}
[bool]{.em}	[stationary_play head]{.functionname}[ ()]{.functionargs}
[void]{.em}	[stem_ex port]{.functionname}[ ()]{.functionargs}
	::: dox Open stem export dialog ::
[void]{.em}	[temporal_zoom_ step]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[toggle_meter_upda ting]{.functionname}[ ()]{.functionargs}
[void]{.em}	[toggle_ruler_v ideo]{.functionname}[ ([bool]{ .em})]{.functionargs}
[void]{.em}	[toggle_xjadeo_ proc]{.functionname}[ ([int]{ .em})]{.functionargs}
[void]{.em}	[update_ grid]{.functionname}[ ()]{.functionargs}
[double]{.em}	[visible_canvas_he ight]{.functionname}[ ()]{.functionargs}

Inherited from ArdourUI:EditingContext

Methods
[TrackViewList](#Ar dourUI:TrackViewList)	[axis_views_from_ro utes]{.functionname}[ ([RouteListP tr](#ARDOUR:RouteList Ptr))]{.functionargs}
[MouseMode ](#Editing.MouseMode)	[current_mouse_ mode]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} The current mouse mode (gain, object, range, timefx etc.) (defined in editing_syms.inc.h) ::: ::
*LuaTable*([Locatio n](#ARDOUR:Location), ...)	[ find_location_from_ma rker]{.functionname}[ ([ArdourMarker](#Ar dourUI:ArdourMarker), [bool&]{ .em})]{.functionargs}
[ArdourMarker](#A rdourUI:ArdourMarker)	[fin d_marker_from_locatio n_id]{.functionname}[ ([ID](#PBD:ID), [bool]{ .em})]{.functionargs}
[long]{.em}	[get_current_ zoom]{.functionname}[ ()]{.functionargs}
[Selection] (#ArdourUI:Selection)	[get_cut_bu ffer]{.functionname}[ ()]{.functionargs}
*LuaTable*([Bea ts](#Temporal:Beats), ...)	[get_draw_length_as_b eats]{.functionname}[ ([bool&]{.em}, [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[int]{.em}	[get_grid_beat_divis ions]{.functionname}[ ([Gri dType](#Editing.GridT ype))]{.functionargs}
*LuaTable*([Bea ts](#Temporal:Beats), ...)	[get_grid_type_as_b eats]{.functionname}[ ([bool&]{.em}, [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
*L uaTable*([timecnt_t]( #Temporal:timecnt_t), ...)	[get_nudge_dist ance]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timecnt _t&](#Temporal:timecn t_t))]{.functionargs}
[Selection] (#ArdourUI:Selection)	[get_selec tion]{.functionname}[ ()]{.functionargs}
[StripableTime AxisView](#ArdourUI:S tripableTimeAxisView)	[get_ stripable_time_axis_b y_id]{.functionname}[ ([ID](#PBD :ID))]{.functionargs}
[double]{.em}	[get_y_or igin]{.functionname}[ ()]{.functionargs}
[GridTyp e](#Editing.GridType)	[grid_ type]{.functionname}[ ()]{.functionargs}
[long]{.em}	[pixel_to_sa mple]{.functionname}[ ([double]{ .em})]{.functionargs}
[void]{.em}	[ redo]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox Redo some transactions. n : Number of transaction to redo. ::
[void]{.em}	[reset_x_or igin]{.functionname}[ ([long]{ .em})]{.functionargs}
	::: dox Queue up a change to the Editor viewport x origin. sample : New x origin. ::
[void]{.em}	[reset_y_or igin]{.functionname}[ ([double]{ .em})]{.functionargs}
[void]{.em}	[reset_ zoom]{.functionname}[ ([long]{ .em})]{.functionargs}
[double]{.em}	[sample_to_p ixel]{.functionname}[ ([long]{ .em})]{.functionargs}
[void]{.em}	[set_mouse_ mode]{.functionname}[ ([MouseMode] (#Editing.MouseMode), [bool]{ .em})]{.functionargs}
	::: dox Set the mouse mode (gain, object, range, timefx etc.) force : Perform the effects of the change even if no change is required (ie even if the current mouse mode is equal to m) m : Mouse mode (defined in editing_syms.inc.h) ::
[void]{.em}	[set_snap_ mode]{.functionname}[ ([Sna pMode](#Editing.SnapM ode))]{.functionargs}
[void]{.em}	[set_zoom_f ocus]{.functionname}[ ([ZoomF ocus](#Editing.ZoomFo cus))]{.functionargs}
[SnapMod e](#Editing.SnapMode)	[snap_ mode]{.functionname}[ ()]{.functionargs}
[void]{.em}	[ undo]{.functionname}[ ([unsigned int]{ .em})]{.functionargs}
	::: dox Undo some transactions. n : Number of transactions to undo. ::
[ZoomFocus ](#Editing.ZoomFocus)	[zoom_f ocus]{.functionname}[ ()]{.functionargs}

∅ ArdourUI:MarkerSelection

C‡: MarkerSelection

is-a: ArdourUI:ArdourMarkerList

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from ArdourUI:ArdourMarkerList

Constructor
ℂ	ArdourUI.ArdourMarkerList ()
Methods
ArdourMarker	back ()
void	clear ()
bool	empty ()
ArdourMarker	front ()
LuaIter	iter ()
.…	push_back (–lua–)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ArdourUI:MidiTimeAxisView

C‡: MidiTimeAxisView

is-a: ArdourUI:TimeAxisView

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

Methods
MidiRegion	add_region (timepos_t, timecnt_t, bool)

Inherited from ArdourUI:TimeAxisView

Methods
[unsigned int]{.em}	[current_he ight]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[effective_he ight]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} effective height (taking children into account) in canvas units, or 0 if this TimeAxisView has not yet been shown ::: ::
[int]{.em}	[o rder]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} index of this TimeAxisView within its parent ::: ::
[void]{.em}	[set_he ight]{.functionname}[ ([unsigned int]{.em}, [TrackH eightMode](#TimeAxisV iew.TrackHeightMode), [bool]{ .em})]{.functionargs}
[int]{.em}	[y_posi tion]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} y position, or -1 if hidden ::: ::
Cast
[Mid iTimeAxisView](#Ardou rUI:MidiTimeAxisView)	[to_midi_time_axis_ view]{.functionname}[ ()]{.functionargs}

∅ ArdourUI:PointSelection

C‡: PointSelection

is-a: ArdourUI:ControlPointList

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from ArdourUI:ControlPointList

Constructor
ℂ	ArdourUI.ControlPointList ()
Methods
ControlPoint	back ()
void	clear ()
bool	empty ()
ControlPoint	front ()
LuaIter	iter ()
.…	push_back (–lua–)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ ArdourUI:RegionSelection

C‡: RegionSelection

Class to represent list of selected regions.

Methods
timepos_t	end_time ()
unsigned long	n_midi_regions ()
RegionList	regionlist ()
timepos_t	start_time ()

∁ ArdourUI:RegionView

C‡: AudioRegionView

is-a: ArdourUI:TimeAxisViewItem

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

Methods
void	hide_region_editor ()
bool	set_region_fx_line (unsigned int, unsigned int)
void	set_region_gain_line ()
void	show_region_editor ()
Cast
RegionView	to_audioregionview ()

Inherited from ArdourUI:TimeAxisViewItem

Methods
[TimeAxisView](#A rdourUI:TimeAxisView)	[get_time_axis_ view]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} the TimeAxisView that this item is on ::: ::

∁ ArdourUI:RouteTimeAxisView

C‡: RouteTimeAxisView

is-a: ArdourUI:RouteUI

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

Cast
StripableTimeAxisView	to_stripabletimeaxisview ()
TimeAxisView	to_timeaxisview ()

∅ ArdourUI:RouteUI

C‡: RouteUI

is-a: ArdourUI:Selectable

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∅ ArdourUI:Selectable

C‡: Selectable

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∁ ArdourUI:Selection

C‡: Selection

Methods
[void]{.em}	[c lear]{.functionname}[ ()]{.functionargs}
	::: dox Clear everything from the Selection ::
[void]{.em}	[clear _all]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[e mpty]{.functionname}[ ([bool]{ .em})]{.functionargs}
	::: dox check if all selections are empty internal_selection : also check object internals (e.g midi notes, automation points), when false only check objects. ::: result-discussion [Re turns]{.word-returns} true if nothing is selected. ::: ::
Data Members
[ArdourUI:Automatio nSelection](#ArdourUI :AutomationSelection)	[ lines]{.functionname}
[ArdourUI:M arkerSelection](#Ardo urUI:MarkerSelection)	[ma rkers]{.functionname}
[ArdourUI :PointSelection](#Ard ourUI:PointSelection)	[p oints]{.functionname}
[ArdourUI:R egionSelection](#Ardo urUI:RegionSelection)	[re gions]{.functionname}
[Ardour UI:TimeSelection](#Ar dourUI:TimeSelection)	[time]{.functionname}
[ArdourUI :TrackSelection](#Ard ourUI:TrackSelection)	[t racks]{.functionname}

∁ ArdourUI:SelectionList

C‡: std::list<Selectable* >

Constructor
ℂ	ArdourUI.SelectionList ()
Methods
Selectable	back ()
void	clear ()
bool	empty ()
Selectable	front ()
LuaIter	iter ()
.…	push_back (–lua–)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∅ ArdourUI:StripableTimeAxisView

C‡: StripableTimeAxisView

is-a: ArdourUI:TimeAxisView

Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.

add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.

notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.

Note that there is no virtual destructor. Don’t use trackable* as pointer type for managing your data or the destructors of your derived types won’t be called when deleting your objects.

 signal

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from ArdourUI:TimeAxisView

Methods
[unsigned int]{.em}	[current_he ight]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[effective_he ight]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} effective height (taking children into account) in canvas units, or 0 if this TimeAxisView has not yet been shown ::: ::
[int]{.em}	[o rder]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} index of this TimeAxisView within its parent ::: ::
[void]{.em}	[set_he ight]{.functionname}[ ([unsigned int]{.em}, [TrackH eightMode](#TimeAxisV iew.TrackHeightMode), [bool]{ .em})]{.functionargs}
[int]{.em}	[y_posi tion]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} y position, or -1 if hidden ::: ::
Cast
[Mid iTimeAxisView](#Ardou rUI:MidiTimeAxisView)	[to_midi_time_axis_ view]{.functionname}[ ()]{.functionargs}

∁ ArdourUI:TimeAxisView

C‡: TimeAxisView

is-a: ArdourUI:AxisView

Methods
[unsigned int]{.em}	[current_he ight]{.functionname}[ ()]{.functionargs}
[unsigned int]{.em}	[effective_he ight]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} effective height (taking children into account) in canvas units, or 0 if this TimeAxisView has not yet been shown ::: ::
[int]{.em}	[o rder]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} index of this TimeAxisView within its parent ::: ::
[void]{.em}	[set_he ight]{.functionname}[ ([unsigned int]{.em}, [TrackH eightMode](#TimeAxisV iew.TrackHeightMode), [bool]{ .em})]{.functionargs}
[int]{.em}	[y_posi tion]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} y position, or -1 if hidden ::: ::
Cast
[Mid iTimeAxisView](#Ardou rUI:MidiTimeAxisView)	[to_midi_time_axis_ view]{.functionname}[ ()]{.functionargs}

∁ ArdourUI:TimeAxisViewItem

C‡: TimeAxisViewItem

is-a: ArdourUI:Selectable

Methods
[TimeAxisView](#A rdourUI:TimeAxisView)	[get_time_axis_ view]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} the TimeAxisView that this item is on ::: ::

∁ ArdourUI:TimeSelection

C‡: TimeSelection

is-a: ARDOUR:TimelineRangeList

Methods
long	end_sample ()
timepos_t	end_time ()
timecnt_t	length ()
long	start_sample ()
timepos_t	start_time ()

Inherited from ARDOUR:TimelineRangeList

Constructor
ℂ	ARDOUR.TimelineRangeList ()
Methods
LuaTable	add (LuaTable {TimelineRange})
TimelineRange	back ()
void	clear ()
bool	empty ()
TimelineRange	front ()
LuaIter	iter ()
void	push_back (TimelineRange)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∅ ArdourUI:TrackSelection

C‡: TrackSelection

is-a: ArdourUI:TrackViewList

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from ArdourUI:TrackViewList

Methods
bool	contains (TimeAxisView)
RouteList	routelist ()
Cast
TrackViewStdList	to_tav_list ()

∁ ArdourUI:TrackViewList

C‡: TrackViewList

Methods
bool	contains (TimeAxisView)
RouteList	routelist ()
Cast
TrackViewStdList	to_tav_list ()

∁ ArdourUI:TrackViewStdList

C‡: std::list<TimeAxisView* >

Constructor
ℂ	ArdourUI.TrackViewStdList ()
Methods
TimeAxisView	back ()
bool	empty ()
TimeAxisView	front ()
LuaIter	iter ()
void	reverse ()
unsigned long	size ()
LuaTable	table ()

∁ ArdourUI:UIConfiguration

C‡: UIConfiguration

Methods
unsigned int	get_action_table_columns ()
TimeSelectionAfterSectionPaste	get_after_section_op ()
bool	get_all_floating_windows_are_dialogs ()
bool	get_allow_non_quarter_pulse ()
bool	get_allow_to_resize_init_dialog ()
bool	get_ask_before_closing_last_window ()
bool	get_ask_cut_copy_section_tempo_map ()
bool	get_automation_edit_cancels_auto_hide ()
bool	get_autoplay_clips ()
bool	get_autoplay_files ()
bool	get_autoscroll_editor ()
bool	get_blink_alert_indicators ()
bool	get_blink_rec_arm ()
bool	get_boxy_buttons ()
bool	get_buggy_gradients ()
bool	get_cairo_image_surface ()
bool	get_check_announcements ()
long	get_clock_display_limit ()
std::string	get_color_file ()
bool	get_color_regions_using_track_color ()
std::string	get_default_bindings ()
int	get_default_lower_midi_note ()
–MISSING (ARDOUR::ColorMode)–	get_default_midi_note_color_mode ()
bool	get_default_narrow_ms ()
int	get_default_upper_midi_note ()
WindowPosition	get_default_window_position ()
int	get_drag_sensitivity ()
float	get_draggable_playhead_speed ()
bool	get_editor_stereo_only_meters ()
bool	get_exclusive_solo_selects_route ()
float	get_extra_ui_extents_time ()
bool	get_flat_buttons ()
bool	get_floating_monitor_section ()
bool	get_follow_edits ()
int	get_font_scale ()
std::string	get_freesound_dir ()
bool	get_grid_follows_internal ()
bool	get_hide_splash_screen ()
bool	get_highlight_auditioned_clips ()
std::string	get_icon_set ()
InputMeterLayout	get_input_meter_layout ()
bool	get_input_meter_scopes ()
unsigned int	get_insert_at_position ()
std::string	get_keyboard_layout ()
std::string	get_keyboard_layout_name ()
bool	get_link_region_and_track_selection ()
unsigned int	get_lock_gui_after_seconds ()
unsigned int	get_max_active_rta ()
unsigned int	get_max_inline_controls ()
int	get_max_note_height ()
int	get_max_plugin_chart ()
int	get_max_plugin_recent ()
float	get_meter_hold ()
MeterLineUp	get_meter_line_up_din ()
MeterLineUp	get_meter_line_up_level ()
float	get_meter_peak ()
bool	get_meter_style_led ()
VUMeterStandard	get_meter_vu_standard ()
std::string	get_mixer_strip_visibility ()
bool	get_name_new_markers ()
bool	get_never_display_periodic_midi ()
bool	get_new_automation_points_on_lane ()
bool	get_no_strobe ()
NoteNameDisplay	get_note_name_display ()
AppleNSGLViewMode	get_nsgl_view_mode ()
bool	get_one_plugin_window_only ()
bool	get_only_copy_imported_files ()
bool	get_open_gui_after_adding_plugin ()
bool	get_open_gui_after_creating_instrument_track ()
PluginGUIBehavior	get_plugin_gui_behavior ()
bool	get_prefer_inline_over_gui ()
bool	get_prefer_tap_tempo ()
bool	get_preview_video_frame_on_drag ()
ClockDeltaMode	get_primary_clock_delta_mode ()
int	get_recent_session_sort ()
RegionEditDisposition	get_region_edit_disposition ()
bool	get_render_plus_hints ()
bool	get_rubberbanding_snaps_to_grid ()
unsigned int	get_ruler_granularity ()
bool	get_rulers_follow_grid ()
bool	get_sandbox_all_lua_scripts ()
bool	get_save_export_analysis_image ()
bool	get_save_export_mixer_screenshot ()
ScreenSaverMode	get_screen_saver_mode ()
bool	get_scroll_velocity_editing ()
ClockDeltaMode	get_secondary_clock_delta_mode ()
bool	get_select_last_drawn_note_only ()
bool	get_sensitize_playhead ()
bool	get_show_editor_meter ()
bool	get_show_grids_ruler ()
bool	get_show_inline_display_by_default ()
bool	get_show_manager_if_plugins_are_missing ()
bool	get_show_mini_timeline ()
bool	get_show_name_highlight ()
bool	get_show_on_cue_page ()
bool	get_show_plugin_scan_window ()
bool	get_show_region_cue_markers ()
bool	get_show_region_gain ()
bool	get_show_region_name ()
bool	get_show_region_xrun_markers ()
bool	get_show_secondary_clock ()
bool	get_show_selection_marker ()
bool	get_show_snapped_cursor ()
bool	get_show_toolbar_cuectrl ()
bool	get_show_toolbar_latency ()
bool	get_show_toolbar_monitor_info ()
bool	get_show_toolbar_monitoring ()
bool	get_show_toolbar_recpunch ()
bool	get_show_toolbar_selclock ()
bool	get_show_track_meters ()
bool	get_show_waveform_clipping ()
bool	get_show_waveforms ()
bool	get_show_waveforms_while_recording ()
bool	get_show_zoom_tools ()
SnapTarget	get_snap_target ()
unsigned int	get_snap_threshold ()
bool	get_snap_to_marks ()
bool	get_snap_to_playhead ()
bool	get_snap_to_region_end ()
bool	get_snap_to_region_start ()
bool	get_snap_to_region_sync ()
bool	get_sound_midi_notes ()
std::string	get_stripable_color_palette ()
bool	get_super_rapid_clock_update ()
int	get_time_axis_name_ellipsize_mode ()
float	get_timeline_item_gradient_depth ()
bool	get_transients_follow_front ()
std::string	get_ui_font_family ()
std::string	get_ui_rc_file ()
bool	get_update_action_scripts ()
bool	get_update_editor_during_summary_drag ()
bool	get_use_cocoa_invalidation ()
bool	get_use_double_click_to_zoom_to_selection ()
bool	get_use_mouse_position_as_zoom_focus_on_scroll ()
bool	get_use_note_bars_for_velocity ()
bool	get_use_palette_for_new_bus ()
bool	get_use_palette_for_new_track ()
bool	get_use_palette_for_new_vca ()
bool	get_use_route_color_widely ()
bool	get_use_time_rulers_to_zoom_with_vertical_drag ()
bool	get_use_tooltips ()
bool	get_use_wm_visibility ()
unsigned int	get_vertical_region_gap ()
std::string	get_vkeybd_layout ()
unsigned long	get_waveform_cache_size ()
double	get_waveform_clip_level ()
float	get_waveform_gradient_depth ()
WaveformScale	get_waveform_scale ()
WaveformShape	get_waveform_shape ()
bool	get_widget_prelight ()
bool	set_action_table_columns (unsigned int)
bool	set_after_section_op (TimeSelectionAfterSectionPaste)
bool	set_all_floating_windows_are_dialogs (bool)
bool	set_allow_non_quarter_pulse (bool)
bool	set_allow_to_resize_init_dialog (bool)
bool	set_ask_before_closing_last_window (bool)
bool	set_ask_cut_copy_section_tempo_map (bool)
bool	set_automation_edit_cancels_auto_hide (bool)
bool	set_autoplay_clips (bool)
bool	set_autoplay_files (bool)
bool	set_autoscroll_editor (bool)
bool	set_blink_alert_indicators (bool)
bool	set_blink_rec_arm (bool)
bool	set_boxy_buttons (bool)
bool	set_buggy_gradients (bool)
bool	set_cairo_image_surface (bool)
bool	set_check_announcements (bool)
bool	set_clock_display_limit (long)
bool	set_color_file (std::string)
bool	set_color_regions_using_track_color (bool)
bool	set_default_bindings (std::string)
bool	set_default_lower_midi_note (int)
bool	set_default_midi_note_color_mode (–MISSING (ARDOUR::ColorMode)–)
bool	set_default_narrow_ms (bool)
bool	set_default_upper_midi_note (int)
bool	set_default_window_position (WindowPosition)
bool	set_drag_sensitivity (int)
bool	set_draggable_playhead_speed (float)
bool	set_editor_stereo_only_meters (bool)
bool	set_exclusive_solo_selects_route (bool)
bool	set_extra_ui_extents_time (float)
bool	set_flat_buttons (bool)
bool	set_floating_monitor_section (bool)
bool	set_follow_edits (bool)
bool	set_font_scale (int)
bool	set_freesound_dir (std::string)
bool	set_grid_follows_internal (bool)
bool	set_hide_splash_screen (bool)
bool	set_highlight_auditioned_clips (bool)
bool	set_icon_set (std::string)
bool	set_input_meter_layout (InputMeterLayout)
bool	set_input_meter_scopes (bool)
bool	set_insert_at_position (unsigned int)
bool	set_keyboard_layout (std::string)
bool	set_keyboard_layout_name (std::string)
bool	set_link_region_and_track_selection (bool)
bool	set_lock_gui_after_seconds (unsigned int)
bool	set_max_active_rta (unsigned int)
bool	set_max_inline_controls (unsigned int)
bool	set_max_note_height (int)
bool	set_max_plugin_chart (int)
bool	set_max_plugin_recent (int)
bool	set_meter_hold (float)
bool	set_meter_line_up_din (MeterLineUp)
bool	set_meter_line_up_level (MeterLineUp)
bool	set_meter_peak (float)
bool	set_meter_style_led (bool)
bool	set_meter_vu_standard (VUMeterStandard)
bool	set_mixer_strip_visibility (std::string)
void	set_modifier (std::string, std::string)
bool	set_name_new_markers (bool)
bool	set_never_display_periodic_midi (bool)
bool	set_new_automation_points_on_lane (bool)
bool	set_no_strobe (bool)
bool	set_note_name_display (NoteNameDisplay)
bool	set_nsgl_view_mode (AppleNSGLViewMode)
bool	set_one_plugin_window_only (bool)
bool	set_only_copy_imported_files (bool)
bool	set_open_gui_after_adding_plugin (bool)
bool	set_open_gui_after_creating_instrument_track (bool)
bool	set_plugin_gui_behavior (PluginGUIBehavior)
bool	set_prefer_inline_over_gui (bool)
bool	set_prefer_tap_tempo (bool)
bool	set_preview_video_frame_on_drag (bool)
bool	set_primary_clock_delta_mode (ClockDeltaMode)
bool	set_recent_session_sort (int)
bool	set_region_edit_disposition (RegionEditDisposition)
bool	set_render_plus_hints (bool)
bool	set_rubberbanding_snaps_to_grid (bool)
bool	set_ruler_granularity (unsigned int)
bool	set_rulers_follow_grid (bool)
bool	set_sandbox_all_lua_scripts (bool)
bool	set_save_export_analysis_image (bool)
bool	set_save_export_mixer_screenshot (bool)
bool	set_screen_saver_mode (ScreenSaverMode)
bool	set_scroll_velocity_editing (bool)
bool	set_secondary_clock_delta_mode (ClockDeltaMode)
bool	set_select_last_drawn_note_only (bool)
bool	set_sensitize_playhead (bool)
bool	set_show_editor_meter (bool)
bool	set_show_grids_ruler (bool)
bool	set_show_inline_display_by_default (bool)
bool	set_show_manager_if_plugins_are_missing (bool)
bool	set_show_mini_timeline (bool)
bool	set_show_name_highlight (bool)
bool	set_show_on_cue_page (bool)
bool	set_show_plugin_scan_window (bool)
bool	set_show_region_cue_markers (bool)
bool	set_show_region_gain (bool)
bool	set_show_region_name (bool)
bool	set_show_region_xrun_markers (bool)
bool	set_show_secondary_clock (bool)
bool	set_show_selection_marker (bool)
bool	set_show_snapped_cursor (bool)
bool	set_show_toolbar_cuectrl (bool)
bool	set_show_toolbar_latency (bool)
bool	set_show_toolbar_monitor_info (bool)
bool	set_show_toolbar_monitoring (bool)
bool	set_show_toolbar_recpunch (bool)
bool	set_show_toolbar_selclock (bool)
bool	set_show_track_meters (bool)
bool	set_show_waveform_clipping (bool)
bool	set_show_waveforms (bool)
bool	set_show_waveforms_while_recording (bool)
bool	set_show_zoom_tools (bool)
bool	set_snap_target (SnapTarget)
bool	set_snap_threshold (unsigned int)
bool	set_snap_to_marks (bool)
bool	set_snap_to_playhead (bool)
bool	set_snap_to_region_end (bool)
bool	set_snap_to_region_start (bool)
bool	set_snap_to_region_sync (bool)
bool	set_sound_midi_notes (bool)
bool	set_stripable_color_palette (std::string)
bool	set_super_rapid_clock_update (bool)
bool	set_time_axis_name_ellipsize_mode (int)
bool	set_timeline_item_gradient_depth (float)
bool	set_transients_follow_front (bool)
bool	set_ui_font_family (std::string)
bool	set_ui_rc_file (std::string)
bool	set_update_action_scripts (bool)
bool	set_update_editor_during_summary_drag (bool)
bool	set_use_cocoa_invalidation (bool)
bool	set_use_double_click_to_zoom_to_selection (bool)
bool	set_use_mouse_position_as_zoom_focus_on_scroll (bool)
bool	set_use_note_bars_for_velocity (bool)
bool	set_use_palette_for_new_bus (bool)
bool	set_use_palette_for_new_track (bool)
bool	set_use_palette_for_new_vca (bool)
bool	set_use_route_color_widely (bool)
bool	set_use_time_rulers_to_zoom_with_vertical_drag (bool)
bool	set_use_tooltips (bool)
bool	set_use_wm_visibility (bool)
bool	set_vertical_region_gap (unsigned int)
bool	set_vkeybd_layout (std::string)
bool	set_waveform_cache_size (unsigned long)
bool	set_waveform_clip_level (double)
bool	set_waveform_gradient_depth (float)
bool	set_waveform_scale (WaveformScale)
bool	set_waveform_shape (WaveformShape)
bool	set_widget_prelight (bool)
Properties
unsigned int	action_table_columns
ARDOUR.TimeSelectionAfterSectionPaste	after_section_op
bool	all_floating_windows_are_dialogs
bool	allow_non_quarter_pulse
bool	allow_to_resize_init_dialog
bool	ask_before_closing_last_window
bool	ask_cut_copy_section_tempo_map
bool	automation_edit_cancels_auto_hide
bool	autoplay_clips
bool	autoplay_files
bool	autoscroll_editor
bool	blink_alert_indicators
bool	blink_rec_arm
bool	boxy_buttons
bool	buggy_gradients
bool	cairo_image_surface
bool	check_announcements
long	clock_display_limit
std::string	color_file
bool	color_regions_using_track_color
std::string	default_bindings
int	default_lower_midi_note
–MISSING (ARDOUR::ColorMode)–	default_midi_note_color_mode
bool	default_narrow_ms
int	default_upper_midi_note
Gtk.WindowPosition	default_window_position
int	drag_sensitivity
float	draggable_playhead_speed
bool	editor_stereo_only_meters
bool	exclusive_solo_selects_route
float	extra_ui_extents_time
bool	flat_buttons
bool	floating_monitor_section
bool	follow_edits
int	font_scale
std::string	freesound_dir
bool	grid_follows_internal
bool	hide_splash_screen
bool	highlight_auditioned_clips
std::string	icon_set
ARDOUR.InputMeterLayout	input_meter_layout
bool	input_meter_scopes
unsigned int	insert_at_position
std::string	keyboard_layout
std::string	keyboard_layout_name
bool	link_region_and_track_selection
unsigned int	lock_gui_after_seconds
unsigned int	max_active_rta
unsigned int	max_inline_controls
int	max_note_height
int	max_plugin_chart
int	max_plugin_recent
float	meter_hold
ARDOUR.MeterLineUp	meter_line_up_din
ARDOUR.MeterLineUp	meter_line_up_level
float	meter_peak
bool	meter_style_led
ARDOUR.VUMeterStandard	meter_vu_standard
std::string	mixer_strip_visibility
bool	name_new_markers
bool	never_display_periodic_midi
bool	new_automation_points_on_lane
bool	no_strobe
Editing.NoteNameDisplay	note_name_display
ARDOUR.AppleNSGLViewMode	nsgl_view_mode
bool	one_plugin_window_only
bool	only_copy_imported_files
bool	open_gui_after_adding_plugin
bool	open_gui_after_creating_instrument_track
ARDOUR.PluginGUIBehavior	plugin_gui_behavior
bool	prefer_inline_over_gui
bool	prefer_tap_tempo
bool	preview_video_frame_on_drag
ARDOUR.ClockDeltaMode	primary_clock_delta_mode
int	recent_session_sort
Editing.RegionEditDisposition	region_edit_disposition
bool	render_plus_hints
bool	rubberbanding_snaps_to_grid
unsigned int	ruler_granularity
bool	rulers_follow_grid
bool	sandbox_all_lua_scripts
bool	save_export_analysis_image
bool	save_export_mixer_screenshot
ARDOUR.ScreenSaverMode	screen_saver_mode
bool	scroll_velocity_editing
ARDOUR.ClockDeltaMode	secondary_clock_delta_mode
bool	select_last_drawn_note_only
bool	sensitize_playhead
bool	show_editor_meter
bool	show_grids_ruler
bool	show_inline_display_by_default
bool	show_manager_if_plugins_are_missing
bool	show_mini_timeline
bool	show_name_highlight
bool	show_on_cue_page
bool	show_plugin_scan_window
bool	show_region_cue_markers
bool	show_region_gain
bool	show_region_name
bool	show_region_xrun_markers
bool	show_secondary_clock
bool	show_selection_marker
bool	show_snapped_cursor
bool	show_toolbar_cuectrl
bool	show_toolbar_latency
bool	show_toolbar_monitor_info
bool	show_toolbar_monitoring
bool	show_toolbar_recpunch
bool	show_toolbar_selclock
bool	show_track_meters
bool	show_waveform_clipping
bool	show_waveforms
bool	show_waveforms_while_recording
bool	show_zoom_tools
ARDOUR.SnapTarget	snap_target
unsigned int	snap_threshold
bool	snap_to_marks
bool	snap_to_playhead
bool	snap_to_region_end
bool	snap_to_region_start
bool	snap_to_region_sync
bool	sound_midi_notes
std::string	stripable_color_palette
bool	super_rapid_clock_update
int	time_axis_name_ellipsize_mode
float	timeline_item_gradient_depth
bool	transients_follow_front
std::string	ui_font_family
std::string	ui_rc_file
bool	update_action_scripts
bool	update_editor_during_summary_drag
bool	use_cocoa_invalidation
bool	use_double_click_to_zoom_to_selection
bool	use_mouse_position_as_zoom_focus_on_scroll
bool	use_note_bars_for_velocity
bool	use_palette_for_new_bus
bool	use_palette_for_new_track
bool	use_palette_for_new_vca
bool	use_route_color_widely
bool	use_time_rulers_to_zoom_with_vertical_drag
bool	use_tooltips
bool	use_wm_visibility
unsigned int	vertical_region_gap
std::string	vkeybd_layout
unsigned long	waveform_cache_size
double	waveform_clip_level
float	waveform_gradient_depth
ARDOUR.WaveformScale	waveform_scale
ARDOUR.WaveformShape	waveform_shape
bool	widget_prelight

⋯ C:ByteArray

C‡: unsigned char*

Methods
LuaMetaTable	array ()
LuaTable	get_table ()
unsigned char*	offset (unsigned int)
void	set_table (LuaTable {unsigned char})

∁ C:ByteVector

C‡: std::vector<unsigned char >

Constructor
ℂ	C.ByteVector ()
ℂ	C.ByteVector ()
Methods
LuaTable	add (LuaTable {unsigned char})
unsigned char	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (unsigned char)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

⋯ C:DoubleArray

C‡: double*

Methods
LuaMetaTable	array ()
LuaTable	get_table ()
DoubleArray	offset (unsigned int)
void	set_table (LuaTable {double})

∁ C:DoubleVector

C‡: std::vector<double >

Constructor
ℂ	C.DoubleVector ()
ℂ	C.DoubleVector ()
Methods
LuaTable	add (LuaTable {double})
double	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (double)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

⋯ C:FloatArray

C‡: float*

Methods
LuaMetaTable	array ()
LuaTable	get_table ()
FloatArray	offset (unsigned int)
void	set_table (LuaTable {float})

∁ C:FloatArrayVector

C‡: std::vector<float* >

Constructor
ℂ	C.FloatArrayVector ()
ℂ	C.FloatArrayVector ()
Methods
LuaTable	add (LuaTable {FloatArray})
FloatArray	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (FloatArray)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ C:FloatVector

C‡: std::vector<float >

Constructor
ℂ	C.FloatVector ()
ℂ	C.FloatVector ()
Methods
LuaTable	add (LuaTable {float})
float	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (float)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ C:Int64List

C‡: std::list<long >

Constructor
ℂ	C.Int64List ()
Methods
LuaTable	add (LuaTable {long})
long	back ()
void	clear ()
bool	empty ()
long	front ()
LuaIter	iter ()
void	push_back (long)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

⋯ C:IntArray

C‡: int*

Methods
LuaMetaTable	array ()
LuaTable	get_table ()
IntArray	offset (unsigned int)
void	set_table (LuaTable {int})

∁ C:IntVector

C‡: std::vector<int >

Constructor
ℂ	C.IntVector ()
ℂ	C.IntVector ()
Methods
LuaTable	add (LuaTable {int})
int	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (int)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ C:StringList

C‡: std::list<std::string >

Constructor
ℂ	C.StringList ()
Methods
LuaTable	add (LuaTable {std::string})
std::string	back ()
void	clear ()
bool	empty ()
std::string	front ()
LuaIter	iter ()
void	push_back (std::string)
void	reverse ()
unsigned long	size ()
LuaTable	table ()
void	unique ()

∁ C:StringVector

C‡: std::vector<std::string >

Constructor
ℂ	C.StringVector ()
ℂ	C.StringVector ()
Methods
LuaTable	add (LuaTable {std::string})
std::string	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (std::string)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ Cairo:Context

C‡: Cairo::Context

Context is the main class used to draw in cairomm. It contains the current state of the rendering device, including coordinates of yet to be drawn shapes.

In the simplest case, create a Context with its target Surface, set its drawing options (line width, color, etc), create shapes with methods like move_to() and line_to(), and then draw the shapes to the Surface using methods such as stroke() or fill().

Context is a reference-counted object that should be used via Cairo::RefPtr.

Methods
[void]{.em}	[arc]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Adds a circular arc of the given radius to the current path. The arc is centered at (xc, yc), begins at angle1 and proceeds in the direction of increasing angles to end at angle2. If angle2 is less than angle1 it will be progressively increased by 2*M_PI until it is greater than angle1. If there is a current point, an initial line segment will be added to the path to connect the current point to the beginning of the arc. If this initial line is undesired, it can be avoided by calling begin_new_sub_path() before calling arc(). Angles are measured in radians. An angle of 0 is in the direction of the positive X axis (in user-space). An angle of M_PI/2.0 radians (90 degrees) is in the direction of the positive Y axis (in user-space). Angles increase in the direction from the positive X axis toward the positive Y axis. So with the default transformation matrix, angles increase in a clockwise direction. ( To convert from degrees to radians, use degrees * (M_PI / 180.0). ) This function gives the arc in the direction of increasing angles; see arc_negative() to get the arc in the direction of decreasing angles. The arc is circular in user-space. To achieve an elliptical arc, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw an ellipse in the box given by x, y, width, height: context->save(); cont ext->translate(x, y); context->scale(width / 2.0, height / 2.0); c ontext->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI); context->restore(); xc : X position of the center of the arc yc : Y position of the center of the arc radius : the radius of the arc angle1 : the start angle, in radians angle2 : the end angle, in radians ::
[void]{.em}	[arc_nega tive]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Adds a circular arc of the given radius to the current path. The arc is centered at (xc, yc), begins at angle1 and proceeds in the direction of decreasing angles to end at angle2. If angle2 is greater than angle1 it will be progressively decreased by 2*M_PI until it is greater than angle1. See arc() for more details. This function differs only in the direction of the arc between the two angles. xc : X position of the center of the arc yc : Y position of the center of the arc radius : the radius of the arc angle1 : the start angle, in radians angle2 : the end angle, in radians ::
[void]{.em}	[begin_new_ path]{.functionname}[ ()]{.functionargs}
	::: dox Clears the current path. After this call there will be no current point. ::
[void]{.em}	[begin_new_sub_ path]{.functionname}[ ()]{.functionargs}
	::: dox Begin a new subpath. Note that the existing path is not affected. After this call there will be no current point. In many cases, this call is not needed since new subpaths are frequently started with move_to(). A call to begin_new_sub_path() is particularly useful when beginning a new subpath with one of the arc() calls. This makes things easier as it is no longer necessary to manually compute the arc's initial coordinates for a call to move_to().
[void]{.em}	[ clip]{.functionname}[ ()]{.functionargs}
	::: dox Establishes a new clip region by intersecting the current clip region with the current Path as it would be filled by fill() and according to the current fill rule. After clip(), the current path will be cleared from the cairo Context. The current clip region affects all drawing operations by effectively masking out any changes to the surface that are outside the current clip region. Calling clip() can only make the clip region smaller, never larger. But the current clip is part of the graphics state, so a temporary restriction of the clip region can be achieved by calling clip() within a save()/restore() pair. The only other means of increasing the size of the clip region is reset_clip(). set_fill_rule() ::
[void]{.em}	[clip_pres erve]{.functionname}[ ()]{.functionargs}
	::: dox Establishes a new clip region by intersecting the current clip region with the current path as it would be filled by fill() and according to the current fill rule. Unlike clip(), clip_preserve preserves the path within the cairo Context. clip() set_fill_rule() ::
[void]{.em}	[close_ path]{.functionname}[ ()]{.functionargs}
	::: dox Adds a line segment to the path from the current point to the beginning of the current subpath, (the most recent point passed to move_to()), and closes this subpath. After this call the current point will be at the joined endpoint of the sub-path. The behavior of close_path() is distinct from simply calling line_to() with the equivalent coordinate in the case of stroking. When a closed subpath is stroked, there are no caps on the ends of the subpath. Instead, there is a line join connecting the final and initial segments of the subpath. If there is no current point before the call to close_path(), this function will have no effect. ::
[void]{.em}	[curv e_to]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{.em}, [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Adds a cubic Bezier spline to the path from the current point to position (x3, y3) in user-space coordinates, using (x1, y1) and (x2, y2) as the control points. After this call the current point will be (x3, y3). If there is no current point before the call to curve_to() this function will behave as if preceded by a call to move_to(x1, y1). x1 : the X coordinate of the first control point y1 : the Y coordinate of the first control point x2 : the X coordinate of the second control point y2 : the Y coordinate of the second control point x3 : the X coordinate of the end of the curve y3 : the Y coordinate of the end of the curve ::
[void]{.em}	[ fill]{.functionname}[ ()]{.functionargs}
	::: dox A drawing operator that fills the current path according to the current fill rule, (each sub-path is implicitly closed before being filled). After fill(), the current path will be cleared from the cairo context. set_fill_rule() fill_preserve() ::
[void]{.em}	[fill_pres erve]{.functionname}[ ()]{.functionargs}
	::: dox A drawing operator that fills the current path according to the current fill rule, (each sub-path is implicitly closed before being filled). Unlike fill(), fill_preserve() preserves the path within the cairo Context. set_fill_rule() fill(). ::
[void]{.em}	[lin e_to]{.functionname}[ ([double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Adds a line to the path from the current point to position (x, y) in user-space coordinates. After this call the current point will be (x, y). If there is no current point before the call to line_to() this function will behave as move_to(x, y). x : the X coordinate of the end of the new line y : the Y coordinate of the end of the new line ::
[void]{.em}	[mov e_to]{.functionname}[ ([double]{.em}, [double]{ .em})]{.functionargs}
	::: dox If the current subpath is not empty, begin a new subpath. After this call the current point will be (x, y). x : the X coordinate of the new position y : the Y coordinate of the new position ::
[void]{.em}	[p aint]{.functionname}[ ()]{.functionargs}
	::: dox A drawing operator that paints the current source everywhere within the current clip region. ::
[void]{.em}	[paint_with_a lpha]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox A drawing operator that paints the current source everywhere within the current clip region using a mask of constant alpha value alpha. The effect is similar to paint(), but the drawing is faded out using the alpha value. alpha : an alpha value, between 0 (transparent) and 1 (opaque) ::
[void]{.em}	[recta ngle]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Adds a closed-subpath rectangle of the given size to the current path at position (x, y) in user-space coordinates. This function is logically equivalent to: co ntext->move_to(x, y); context->r el_line_to(width, 0); context->re l_line_to(0, height); context->re l_line_to(-width, 0); c ontext->close_path(); x : the X coordinate of the top left corner of the rectangle y : the Y coordinate to the top left corner of the rectangle width : the width of the rectangle height : the height of the rectangle ::
[void]{.em}	[rel_curv e_to]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{.em}, [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Relative-coordinate version of curve_to(). All offsets are relative to the current point. Adds a cubic Bezier spline to the path from the current point to a point offset from the current point by (dx3, dy3), using points offset by (dx1, dy1) and (dx2, dy2) as the control points. After this call the current point will be offset by (dx3, dy3). Given a current point of (x, y), rel_curve_to(dx1, dy1 , dx2, dy2, dx3, dy3) is logically equivalent to curve_to(x + dx1, y + dy1, x + dx2, y + dy 2, x + dx3, y + dy3). It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STA TUS_NO_CURRENT_POINT. Cairomm will then throw an exception. dx1 : the X offset to the first control point dy1 : the Y offset to the first control point dx2 : the X offset to the second control point dy2 : the Y offset to the second control point dx3 : the X offset to the end of the curve dy3 : the Y offset to the end of the curve ::
[void]{.em}	[rel_lin e_to]{.functionname}[ ([double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Relative-coordinate version of line_to(). Adds a line to the path from the current point to a point that is offset from the current point by (dx, dy) in user space. After this call the current point will be offset by (dx, dy). Given a current point of (x, y), rel_line_to(dx, dy) is logically equivalent to lin e_to(x + dx, y + dy). It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STA TUS_NO_CURRENT_POINT. Cairomm will then throw an exception. dx : the X offset to the end of the new line dy : the Y offset to the end of the new line ::
[void]{.em}	[rel_mov e_to]{.functionname}[ ([double]{.em}, [double]{ .em})]{.functionargs}
	::: dox If the current subpath is not empty, begin a new subpath. After this call the current point will offset by (x, y). Given a current point of (x, y), rel_move_to(dx, dy) is logically equivalent to mo ve_to(x + dx, y + dy) It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STA TUS_NO_CURRENT_POINT. Cairomm will then throw an exception. dx : the X offset dy : the Y offset ::
[void]{.em}	[reset_ clip]{.functionname}[ ()]{.functionargs}
	::: dox Reset the current clip region to its original, unrestricted state. That is, set the clip region to an infinitely large shape containing the target surface. Equivalently, if infinity is too hard to grasp, one can imagine the clip region being reset to the exact bounds of the target surface. Note that code meant to be reusable should not call reset_clip() as it will cause results unexpected by higher-level code which calls clip(). Consider using save() and restore() around clip() as a more robust means of temporarily restricting the clip region. ::
[void]{.em}	[res tore]{.functionname}[ ()]{.functionargs}
	::: dox Restores cr to the state saved by a preceding call to save() and removes that state from the stack of saved states. save() ::
[void]{.em}	[ro tate]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox Modifies the current transformation matrix (CTM) by rotating the user-space axes by angle radians. The rotation of the axes takes places after any existing transformation of user space. The rotation direction for positive angles is from the positive X axis toward the positive Y axis. angle : angle (in radians) by which the user-space axes will be rotated ::
[void]{.em}	[ save]{.functionname}[ ()]{.functionargs}
	::: dox Makes a copy of the current state of the Context and saves it on an internal stack of saved states. When restore() is called, it will be restored to the saved state. Multiple calls to save() and restore() can be nested; each call to restore() restores the state from the matching paired save(). It isn't necessary to clear all saved states before a cairo_t is freed. Any saved states will be freed when the Context is destroyed. restore() ::
[void]{.em}	[s cale]{.functionname}[ ([double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Modifies the current transformation matrix (CTM) by scaling the X and Y user-space axes by sx and sy respectively. The scaling of the axes takes place after any existing transformation of user space. sx : scale factor for the X dimension sy : scale factor for the Y dimension ::
[void]{.em}	[set_ dash]{.functionname}[ ([DoubleVect or](#C:DoubleVector), [double]{ .em})]{.functionargs}
	::: dox Sets the dash pattern to be used by stroke(). A dash pattern is specified by dashes, an array of positive values. Each value provides the user-space length of altenate "on" and "off" portions of the stroke. The offset specifies an offset into the pattern at which the stroke begins. Each "on" segment will have caps applied as if the segment were a separate sub-path. In particular, it is valid to use an "on" length of 0.0 with Cairo::LINE_CAP_ROUND or C airo::LINE_CAP_SQUARE in order to distributed dots or squares along a path. Note: The length values are in user-space units as evaluated at the time of stroking. This is not necessarily the same as the user space at the time of set_dash(). If dashes is empty dashing is disabled. If the size of dashes is 1, a symmetric pattern is assumed with alternating on and off portions of the size specified by the single value in dashes. It is invalid for any value in dashes to be negative, or for all values to be 0. If this is the case, an exception will be thrown dashes : an array specifying alternate lengths of on and off portions offset : an offset into the dash pattern at which the stroke should start ::
[void]{.em}	[set_font_ size]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox Sets the current font matrix to a scale by a factor of size, replacing any font matrix previously set with set_font_size() or set_font_matrix(). This results in a font size of size user space units. (More precisely, this matrix will result in the font's em-square being a by size square in user space.) If text is drawn without a call to set_font_size(), (nor set_font_matrix() nor set_scaled_font()), the default font size is 10.0. size : the new font size, in user space units) ::
[void]{.em}	[set_line _cap]{.functionname}[ ( [LineCap](#Cairo.Line Cap))]{.functionargs}
	::: dox Sets the current line cap style within the cairo Context. See LineCap for details about how the available line cap styles are drawn. As with the other stroke parameters, the current line cap style is examined by stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction. The default line cap style is Cairo::LINE_CAP_BUTT. line_cap : a line cap style, as a LineCap ::
[void]{.em}	[set_line_ join]{.functionname}[ ([L ineJoin](#Cairo.LineJ oin))]{.functionargs}
	::: dox Sets the current line join style within the cairo Context. See LineJoin for details about how the available line join styles are drawn. As with the other stroke parameters, the current line join style is examined by stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction. The default line join style is Ca iro::LINE_JOIN_MITER. line_join : a line joint style, as a LineJoin ::
[void]{.em}	[set_line_w idth]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox Sets the current line width within the cairo Context. The line width specifies the diameter of a pen that is circular in user-space, (though device-space pen may be an ellipse in general due to s caling/shear/rotation of the CTM). Note: When the description above refers to user space and CTM it refers to the user space and CTM in effect at the time of the stroking operation, not the user space and CTM in effect at the time of the call to set_line_width(). The simplest usage makes both of these spaces identical. That is, if there is no change to the CTM between a call to set_line_width() and the stroking operation, then one can just pass user-space values to set_line_width() and ignore this note. As with the other stroke parameters, the current line cap style is examined by stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction. The default line width value is 2.0. width : a line width, as a user-space value ::
[void]{.em}	[set_oper ator]{.functionname}[ ([O perator](#Cairo.Opera tor))]{.functionargs}
	::: dox Sets the compositing operator to be used for all drawing operations. See Operator for details on the semantics of each available compositing operator. op : a compositing operator, specified as a Operator ::
[void]{.em}	[set_source _rgb]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Sets the source pattern within the Context to an opaque color. This opaque color will then be used for any subsequent drawing operation until a new source pattern is set. The color components are floating point numbers in the range 0 to 1. If the values passed in are outside that range, they will be clamped. set_source_rgba() set_source() red : red component of color green : green component of color blue : blue component of color ::
[void]{.em}	[set_source_ rgba]{.functionname}[ ([double]{.em}, [double]{.em}, [double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Sets the source pattern within the Context to a translucent color. This color will then be used for any subsequent drawing operation until a new source pattern is set. The color and alpha components are floating point numbers in the range 0 to 1. If the values passed in are outside that range, they will be clamped. set_source_rgb() set_source() red : red component of color green : green component of color blue : blue component of color alpha : alpha component of color ::
[void]{.em}	[show_ text]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox A drawing operator that generates the shape from a string of UTF-8 characters, rendered according to the current font_face, font_size (font_matrix), and font_options. This function first computes a set of glyphs for the string of text. The first glyph is placed so that its origin is at the current point. The origin of each subsequent glyph is offset from that of the previous glyph by the advance values of the previous glyph. After this call the current point is moved to the origin of where the next glyph would be placed in this same progression. That is, the current point will be at the origin of the final glyph offset by its advance values. This allows for easy display of a single logical string with multiple calls to show_text(). Note: The show_text() function call is part of what the cairo designers call the "toy" text API. It is convenient for short demos and simple programs, but it is not expected to be adequate for serious text-using applications. See show_glyphs() for the "real" text display API in cairo. utf8 : a string containing text encoded in UTF-8 ::
[void]{.em}	[st roke]{.functionname}[ ()]{.functionargs}
	::: dox A drawing operator that strokes the current Path according to the current line width, line join, line cap, and dash settings. After stroke(), the current Path will be cleared from the cairo Context. set_line_width() set_line_join() set_line_cap() set_dash() stroke_preserve(). Note: Degenerate segments and sub-paths are treated specially and provide a useful result. These can result in two different situations: 1. Zero-length "on" segments set in set_dash(). If the cap style is Cairo::LINE_CAP_ROUND or C airo::LINE_CAP_SQUARE then these segments will be drawn as circular dots or squares respectively. In the case of Ca iro::LINE_CAP_SQUARE, the orientation of the squares is determined by the direction of the underlying path. 2. A sub-path created by move_to() followed by either a close_path() or one or more calls to line_to() to the same coordinate as the move_to(). If the cap style is Cairo::LINE_CAP_ROUND then these sub-paths will be drawn as circular dots. Note that in the case of C airo::LINE_CAP_SQUARE a degenerate sub-path will not be drawn at all, (since the correct orientation is indeterminate). In no case will a cap style of Cairo::LINE_CAP_BUTT cause anything to be drawn in the case of either degenerate segments or sub-paths. ::
[void]{.em}	[stroke_pres erve]{.functionname}[ ()]{.functionargs}
	::: dox A drawing operator that strokes the current Path according to the current line width, line join, line cap, and dash settings. Unlike stroke(), stroke_preserve() preserves the Path within the cairo Context. set_line_width() set_line_join() set_line_cap() set_dash() stroke_preserve(). ::
[void]{.em}	[trans late]{.functionname}[ ([double]{.em}, [double]{ .em})]{.functionargs}
	::: dox Modifies the current transformation matrix (CTM) by translating the user-space origin by (tx, ty). This offset is interpreted as a user-space coordinate according to the CTM in place before the new call to translate. In other words, the translation of the user-space origin takes place after any existing transformation. tx : amount to translate in the X direction ty : amount to translate in the Y direction ::
[void]{.em}	[unset_ dash]{.functionname}[ ()]{.functionargs}
	::: dox This function disables a dash pattern that was set with set_dash() ::

∁ Cairo:ImageSurface

C‡: LuaCairo::ImageSurface

Constructor
ℂ	[Cairo.ImageSur face]{.functionname}[ ([Fo rmat](#Cairo.Format), [int]{.em}, [int]{ .em})]{.functionargs}
Methods
[Con text](#Cairo:Context)	[con text]{.functionname}[ ()]{.functionargs}
	::: dox Returns a context object to perform operations on the surface ::
[int]{.em}	[get_he ight]{.functionname}[ ()]{.functionargs}
	::: dox Gets the height of the ImageSurface in pixels ::
[int]{.em}	[get_st ride]{.functionname}[ ()]{.functionargs}
	::: dox Returns the stride of the image surface in bytes (or 0 if surface is not an image surface). The stride is the distance in bytes from the beginning of one row of the image data to the beginning of the next row. ::
[int]{.em}	[get_w idth]{.functionname}[ ()]{.functionargs}
	::: dox Gets the width of the ImageSurface in pixels ::
[void]{.em}	[set_as_so urce]{.functionname}[ ([Cont ext](#Cairo:Context), [int]{.em}, [int]{ .em})]{.functionargs}
	::: dox Set this surface as source for another context. This allows to draw this surface ::

∁ Cairo:PangoLayout

C‡: LuaCairo::PangoLayout

Constructor
ℂ	[Cairo.PangoLa yout]{.functionname}[ ([Cont ext](#Cairo:Context), [std::string]{ .em})]{.functionargs}
Methods
[Alignme nt](#Pango.Alignment)	[get_align ment]{.functionname}[ ()]{.functionargs}
	::: dox Gets the alignment for the layout: how partial lines are positioned within the horizontal space available. ::: result-discussion [Re turns]{.word-returns} The alignment. ::: ::
[EllipsizeMode]( #Pango.EllipsizeMode)	[get_ellip size]{.functionname}[ ()]{.functionargs}
	::: dox Gets the type of ellipsization being performed for layout. See set_ellipsize() Use is_ellipsized() to query whether any paragraphs were actually ellipsized. ::: result-discussion [Re turns]{.word-returns} The current ellipsization mode for layout. ::: ::
...	[get_pixel_ size]{.functionname}[ ([--lua--]{ .em})]{.functionargs}
	::: dox Determines the logical width and height of a Pango::Layout in device units. ::
[std::string]{.em}	[get_ text]{.functionname}[ ()]{.functionargs}
	::: dox Gets the text in the layout. The returned text should not be freed or modified. ::: result-discussion [Re turns]{.word-returns} The text in the layout. ::: ::
[WrapM ode](#Pango.WrapMode)	[get_ wrap]{.functionname}[ ()]{.functionargs}
	::: dox Gets the wrap mode for the layout. Use is_wrapped() to query whether any paragraphs were actually wrapped. ::: result-discussion [Re turns]{.word-returns} Active wrap mode. ::: ::
[bool]{.em}	[is_ellips ized]{.functionname}[ ()]{.functionargs}
	::: dox Queries whether the layout had to ellipsize any paragraphs. This returns true if the ellipsization mode for layout is not P ango::ELLIPSIZE_NONE, a positive width is set on layout, and there are paragraphs exceeding that width that have to be ellipsized. ::: result-discussion [Re turns]{.word-returns} true if any paragraphs had to be ellipsized, false otherwise. ::: ::
[bool]{.em}	[is_wra pped]{.functionname}[ ()]{.functionargs}
	::: dox Queries whether the layout had to wrap any paragraphs. This returns true if a positive width is set on layout, ellipsization mode of layout is set to P ango::ELLIPSIZE_NONE, and there are paragraphs exceeding the layout width that have to be wrapped. ::: result-discussion [Re turns]{.word-returns} true if any paragraphs had to be wrapped, false otherwise. ::: ::
[void]{.em}	[layout_cairo_ path]{.functionname}[ ( [Context](#Cairo:Cont ext))]{.functionargs}
[void]{.em}	[set_align ment]{.functionname}[ ([Ali gnment](#Pango.Alignm ent))]{.functionargs}
	::: dox Sets the alignment for the layout: how partial lines are positioned within the horizontal space available. alignment : The alignment. ::
[void]{.em}	[set_ellip size]{.functionname}[ ([EllipsizeMo de](#Pango.EllipsizeM ode))]{.functionargs}
	::: dox Sets the type of ellipsization being performed for layout. Depending on the ellipsization mode ellipsize text is removed from the start, middle, or end of text so they fit within the width and height of layout set with set_width() and set_height(). If the layout contains characters such as newlines that force it to be layed out in multiple paragraphs, then whether each paragraph is ellipsized separately or the entire layout is ellipsized as a whole depends on the set height of the layout. See set_height() for details. ellipsize : The new ellipsization mode for layout. ::
[void]{.em}	[set_ma rkup]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Sets the layout text and attribute list from marked-up text (see markup format). Replaces the current text and attribute list. markup : Some marked-up text. ::
[void]{.em}	[set_ text]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Set the text of the layout. text : The text for the layout. ::
[void]{.em}	[set_w idth]{.functionname}[ ([float]{ .em})]{.functionargs}
	::: dox Sets the width to which the lines of the Pango::Layout should wrap or ellipsized. The default value is -1: no width set. width : The desired width in Pango units, or -1 to indicate that no wrapping or ellipsization should be performed. ::
[void]{.em}	[set_ wrap]{.functionname}[ ([W rapMode](#Pango.WrapM ode))]{.functionargs}
	::: dox Sets the wrap mode; the wrap mode only has effect if a width is set on the layout with set_width(). To turn off wrapping, set the width to -1. wrap : The wrap mode. ::
[void]{.em}	[show_in_cairo_con text]{.functionname}[ ( [Context](#Cairo:Cont ext))]{.functionargs}
	::: dox Draws a Layout in the specified Cairo context. The top-left corner of the Layout will be drawn at the current point of the cairo context. context : A Cairo context. ::

↠ Evoral:Control

C‡: std::shared_ptr< Evoral::Control >, std::weak_ptr< Evoral::Control >

Base class representing some kind of (automatable) control; a fader’s gain, for example, or a compressor plugin’s threshold.

The class knows the Evoral::Parameter that it is controlling, and has a list of values for automation.

Methods
bool	isnil ()
ControlList	list ()

∁ Evoral:ControlEvent

C‡: Evoral::ControlEvent

A single event (time-stamped value) for a control

Data Members
double	value
Temporal:timepos_t	when

↠ Evoral:ControlList

C‡: std::shared_ptr< Evoral::ControlList >, std::weak_ptr< Evoral::ControlList >

Methods
[void]{.em}	[add]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [double]{.em}, [bool]{.em}, [bool]{ .em})]{.functionargs}
[void]{.em}	[c lear]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[clear_ list]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[editor _add]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [double]{.em}, [bool]{ .em})]{.functionargs}
[double]{.em}	[ eval]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[EventLis t](#ARDOUR:EventList)	[ev ents]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} the list of events ::: ::
[bool]{.em}	[in_write_ pass]{.functionname}[ ()]{.functionargs}
	::: dox ::: result-discussion [Re turns]{.word-returns} true if transport is running and this list is in write mode ::: ::
[InterpolationStyl e](#Evoral.ControlLis t.InterpolationStyle)	[interpola tion]{.functionname}[ ()]{.functionargs}
	::: dox query interpolation style of the automation data ::: result-discussion [Re turns]{.word-returns} Interpolation Style ::: ::
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
*Lua Table*([double]{.em}, ...)	[rt_safe_ eval]{.functionname}[ ([timepos_t]( #Temporal:timepos_t), [bool&]{ .em})]{.functionargs}
[bool]{.em}	[set_interpola tion]{.functionname}[ ([Interpolation Style](#Evoral.Contro lList.InterpolationSt yle))]{.functionargs}
[unsigned long]{.em}	[ size]{.functionname}[ ()]{.functionargs}
[void]{.em}	[ thin]{.functionname}[ ([double]{ .em})]{.functionargs}
	::: dox Thin the number of events in this list. The thinning factor corresponds to the area of a triangle computed between three points in the list (time-difference * value-difference). If the area is large, it indicates significant non-linearity between the points. Time is measured in samples, value is usually normalized to 0..1. During automation recording we thin the recorded points using this value. If a point is sufficiently co-linear with its neighbours (as defined by the area of the triangle formed by three of them), we will not include it in the list. The larger the value, the more points are excluded, so this effectively measures the amount of thinning to be done. thinning_factor : area-size (default: 20) ::
[void]{.em}	[truncate _end]{.functionname}[ ([timepo s_t](#Temporal:timepo s_t))]{.functionargs}
[void]{.em}	[truncate_s tart]{.functionname}[ ([timecn t_t](#Temporal:timecn t_t))]{.functionargs}
Cast
[AutomationList](#A RDOUR:AutomationList)	[to_automation list]{.functionname}[ ()]{.functionargs}

↠ Evoral:ControlSet

C‡: std::shared_ptr< Evoral::ControlSet >, std::weak_ptr< Evoral::ControlSet >

Methods
bool	isnil ()

∁ Evoral:Event

C‡: Evoral::Event<long>

Methods
unsigned char*	buffer ()
unsigned char	channel ()
void	clear ()
void	set_buffer (unsigned int, unsigned char*, bool)
void	set_channel (unsigned char)
void	set_type (unsigned char)
unsigned int	size ()
long	time ()
unsigned char	_type ()

↠ Evoral:EventPtr

C‡: std::shared_ptr< Evoral::Event<Temporal::Beats> >, std::weak_ptr< Evoral::Event<Temporal::Beats> >

Methods
bool	isnil ()
unsigned int	size ()
Beats	time ()

↠ Evoral:NotePtr

C‡: std::shared_ptr< Evoral::Note<Temporal::Beats> >, std::weak_ptr< Evoral::Note<Temporal::Beats> >

Methods
unsigned char	channel ()
bool	isnil ()
Beats	length ()
unsigned char	note ()
unsigned char	off_velocity ()
Beats	time ()
unsigned char	velocity ()

∁ Evoral:Parameter

C‡: Evoral::Parameter

ID of a [play|record|automate]able parameter.

A parameter is defined by (type, id, channel). Type is an integer which can be used in any way by the application (e.g. cast to a custom enum, map to/from a URI, etc). ID is type specific (e.g. MIDI controller #).

This class defines a < operator which is a strict weak ordering, so Parameter may be stored in a std::set, used as a std::map key, etc.

Constructor
ℂ	Evoral.Parameter (unsigned int, unsigned char, unsigned int)
Methods
unsigned char	channel ()
unsigned int	id ()
unsigned int	_type ()

∁ Evoral:ParameterDescriptor

C‡: Evoral::ParameterDescriptor

Description of the value range of a parameter or control.

Constructor
ℂ	[E voral.ParameterDescri ptor]{.functionname}[ ()]{.functionargs}
Data Members
[bool]{.em}	[logari thmic]{.functionname}
	::: dox True for log-scale parameters ::
[float]{.em}	[ lower]{.functionname}
	::: dox Minimum value (in Hz, for frequencies) ::
[float]{.em}	[n ormal]{.functionname}
	::: dox Default value ::
[unsigned int]{.em}	[range steps]{.functionname}
	::: dox number of steps, [min,max] (inclusive). <= 1 means continuous. == 2 only min, max. For integer controls this is usually (1 + max - min) ::
[bool]{.em}	[to ggled]{.functionname}
	::: dox True iff parameter is boolean ::
[float]{.em}	[ upper]{.functionname}
	::: dox Maximum value (in Hz, for frequencies) ::

↠ Evoral:PatchChangePtr

C‡: std::shared_ptr< Evoral::PatchChange<Temporal::Beats> >, std::weak_ptr< Evoral::PatchChange<Temporal::Beats> >

Methods
int	bank ()
bool	isnil ()
unsigned char	program ()
Beats	time ()

∁ Evoral:Range

C‡: Temporal::Range

Constructor
ℂ	Evoral.Range (timepos_t, timepos_t)
Methods
timepos_t	_end ()
timepos_t	start ()

↠ Evoral:Sequence

C‡: std::shared_ptr< Evoral::Sequence<Temporal::Beats> >, std::weak_ptr< Evoral::Sequence<Temporal::Beats> >

is-a: Evoral:ControlSet

Methods
bool	isnil ()

ℕ Keyboard

Data Members
unsigned int	CopyModifier
unsigned int	GainExtraFineScaleModifier
unsigned int	GainFineScaleModifier
unsigned int	RangeSelectModifier
unsigned int	ScrollHorizontalModifier
unsigned int	ScrollZoomHorizontalModifier
unsigned int	ScrollZoomVerticalModifier

∁ LuaDialog:Dialog

C‡: LuaDialog::Dialog

Constructor
ℂ	LuaDialog.Dialog (std::string, Lua-Function)
Methods
.…	run (–lua–)

∁ LuaDialog:Message

C‡: LuaDialog::Message

Constructor
ℂ	LuaDialog.Message (std::string, std::string, MessageType, ButtonType)
Methods
int	run ()

∁ LuaDialog:ProgressWindow

C‡: LuaDialog::ProgressWindow

Constructor
ℂ	[LuaDialog.ProgressWi ndow]{.functionname}[ ([std::string]{.em}, [bool]{ .em})]{.functionargs}
Methods
[bool]{.em}	[canc eled]{.functionname}[ ()]{.functionargs}
[void]{.em}	[ done]{.functionname}[ ()]{.functionargs}
	::: dox Close and hide the dialog. This is required to be at the end, since the dialog is modal and prevents other UI operations while visible. ::
[bool]{.em}	[prog ress]{.functionname}[ ([float]{.em}, [std::string]{ .em})]{.functionargs}
	::: dox Report progress and update GUI. prog : progress in range 0..1 show a bar, values outside this range show a pulsing dialog. text : optional text to show on the progress-bar ::: result-discussion [Re turns]{.word-returns} true if cancel was clicked, false otherwise ::: ::

∁ LuaSignal:Set

C‡: std::bitset<50ul>

Constructor
ℂ	LuaSignal.Set ()
Methods
LuaTable	add (50ul)
bool	any ()
unsigned long	count ()
bool	none ()
Set	reset ()
Set	set (unsigned long, bool)
unsigned long	size ()
LuaTable	table ()
bool	test (unsigned long)

ℕ PBD

Methods
unsigned int	hardware_concurrency ()
int	max_mmcss_threads_per_process ()
bool	open_uri (std::string)
bool	open_uri (std::string)

∁ PBD:Command

C‡: PBD::Command

is-a: PBD:StatefulDestructible

Base class for Undo/Redo commands and changesets

Methods
std::string	name ()
void	set_name (std::string)

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∅ PBD:Configuration

C‡: PBD::Configuration

is-a: PBD:Stateful

Base class for objects with saveable and undoable state

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ PBD:Controllable

C‡: std::shared_ptr< PBD::Controllable >, std::weak_ptr< PBD::Controllable >

is-a: PBD:StatefulDestructiblePtr

This is a pure virtual class to represent a scalar control.

Note that it contains no storage/state for the controllable thing that it represents. Derived classes must provide set_value()/get_value() methods, which will involve (somehow) an actual location to store the value.

In essence, this is an interface, not a class.

Without overriding upper() and lower(), a derived class will function as a control whose value can range between 0 and 1.0.

We express Controllable values in one of three ways: 1. `user’ — as presented to the user (e.g. dB, Hz, etc.) 2. `interface’ — as used in some cases for the UI representation (in order to make controls behave logarithmically). 3. `internal’ — as passed to a processor, track, plugin, or whatever.

Note that in some cases user and internal may be the same (and interface different) e.g. frequency, which is presented to the user and passed to the processor in linear terms, but which needs log scaling in the interface.

In other cases, user and interface may be the same (and internal different) e.g. gain, which is presented to the user in log terms (dB) but passed to the processor as a linear quantity.

Methods
[void]{.em}	[dump_regi stry]{.functionname}[ ()]{.functionargs}
[double]{.em}	[get_v alue]{.functionname}[ ()]{.functionargs}
	::: dox Get `internal' value ::: result-discussion [Re turns]{.word-returns} raw value as used for the plugin/processor control port ::: ::
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[std::string]{.em}	[ name]{.functionname}[ ()]{.functionargs}
[ControllableSet](#AR DOUR:ControllableSet)	[registered_controlla bles]{.functionname}[ ()]{.functionargs}
Cast
[Aut omationControl](#ARDO UR:AutomationControl)	[to_automationcon trol]{.functionname}[ ()]{.functionargs}
[MPGainControl](# ARDOUR:MPGainControl)	[to_mp gain]{.functionname}[ ()]{.functionargs}
[MPToggleControl](#AR DOUR:MPToggleControl)	[to_mpto ggle]{.functionname}[ ()]{.functionargs}

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ PBD:HistoryOwner

C‡: PBD::HistoryOwner

Methods
[bool]{.em}	[abort _empty_reversible_com mand]{.functionname}[ ()]{.functionargs}
	::: dox Abort reversible command IFF no undo changes have been collected. ::: result-discussion [Re turns]{.word-returns} true if undo operation was aborted. ::: ::
[void]{.em}	[abort_reversible_com mand]{.functionname}[ ()]{.functionargs}
	::: dox abort an open undo command This must only be called after beg in_reversible_command () ::
[void]{.em}	[add_com mand]{.functionname}[ ([Command](#PBD:Comm and))]{.functionargs}
[Stat efulDiffCommand](#PBD :StatefulDiffCommand)	[ add_stateful_diff_com mand]{.functionname}[ ([Stateful DestructiblePtr](#PBD :StatefulDestructible Ptr))]{.functionargs}
	::: dox create an StatefulDiffCommand from the given object and add it to the stack. This function must only be called after begi n_reversible_command. Failing to do so may lead to a crash. sfd : the object to diff ::: result-discussion [Re turns]{.word-returns} the allocated StatefulDiffCommand (already added via add_command) ::: ::
[void]{.em}	[begin_reversible_com mand]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox begin collecting undo information This call must always be followed by either begin _reversible_command() or commit _reversible_command() cmd_name : human readable name for the undo operation ::
[bool]{.em}	[collected_undo_comm ands]{.functionname}[ ()]{.functionargs}
	::: dox Test if any undo commands were added since the call to beg in_reversible_command () This is useful to determine if an undoable action was performed before adding additional information (e.g. selection changes) to the undo transaction. ::: result-discussion [Re turns]{.word-returns} true if undo operation is valid but empty ::: ::
[void]{.em}	[ commit_reversible_com mand]{.functionname}[ ([Command](#PBD:Comm and))]{.functionargs}
	::: dox finalize an undo command and commit pending transactions This must only be called after beg in_reversible_command () cmd : (additional) command to add ::

∁ PBD:ID

C‡: PBD::ID

a unique ID to identify objects numerically

Constructor
ℂ	PBD.ID (std::string)
Methods
std::string	to_s ()

∁ PBD:IdVector

C‡: std::vector<PBD::ID >

Constructor
ℂ	PBD.IdVector ()
ℂ	PBD.IdVector ()
Methods
LuaTable	add (LuaTable {ID})
ID	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (ID)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∅ PBD:Progress

C‡: PBD::Progress

A class to handle reporting of progress of something

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

∁ PBD:RingBuffer8

C‡: PBD::RingBufferNPT<unsigned char>

Constructor
ℂ	PBD.RingBuffer8 (unsigned long)
Methods
void	increment_read_ptr (unsigned long)
void	increment_write_ptr (unsigned long)
unsigned long	read (unsigned char*, unsigned long)
unsigned long	read_space ()
void	reset ()
unsigned long	write (unsigned char*, unsigned long)
unsigned long	write_one (unsigned char)
unsigned long	write_space ()

∁ PBD:RingBufferF

C‡: PBD::RingBufferNPT<float>

Constructor
ℂ	PBD.RingBufferF (unsigned long)
Methods
void	increment_read_ptr (unsigned long)
void	increment_write_ptr (unsigned long)
unsigned long	read (FloatArray, unsigned long)
unsigned long	read_space ()
void	reset ()
unsigned long	write (FloatArray, unsigned long)
unsigned long	write_one (float)
unsigned long	write_space ()

∁ PBD:RingBufferI

C‡: PBD::RingBufferNPT<int>

Constructor
ℂ	PBD.RingBufferI (unsigned long)
Methods
void	increment_read_ptr (unsigned long)
void	increment_write_ptr (unsigned long)
unsigned long	read (IntArray, unsigned long)
unsigned long	read_space ()
void	reset ()
unsigned long	write (IntArray, unsigned long)
unsigned long	write_one (int)
unsigned long	write_space ()

∁ PBD:Stateful

C‡: PBD::Stateful

Base class for objects with saveable and undoable state

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∅ PBD:StatefulDestructible

C‡: PBD::StatefulDestructible

is-a: PBD:Stateful

Base class for objects with saveable and undoable state with destruction notification

This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ PBD:StatefulDestructiblePtr

C‡: std::shared_ptr< PBD::StatefulDestructible >, std::weak_ptr< PBD::StatefulDestructible >

is-a: PBD:StatefulPtr

Base class for objects with saveable and undoable state with destruction notification

Methods
bool	isnil ()

Inherited from PBD:StatefulPtr

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ PBD:StatefulDiffCommand

C‡: PBD::StatefulDiffCommand

is-a: PBD:Command

A Command which stores its action as the differences between the before and after state of a Stateful object.

Methods
bool	empty ()
void	undo ()

Inherited from PBD:Command

Methods
std::string	name ()
void	set_name (std::string)

Inherited from PBD:Stateful

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

↠ PBD:StatefulPtr

C‡: std::shared_ptr< PBD::Stateful >, std::weak_ptr< PBD::Stateful >

Base class for objects with saveable and undoable state

Methods
[void]{.em}	[clear_cha nges]{.functionname}[ ()]{.functionargs}
	::: dox Forget about any changes to this object's properties ::
[ID](#PBD:ID)	[id]{.functionname}[ ()]{.functionargs}
[bool]{.em}	[i snil]{.functionname}[ ()]{.functionargs}
[Own edPropertyList](#ARDO UR:OwnedPropertyList)	[proper ties]{.functionname}[ ()]{.functionargs}

∁ PBD:XMLNode

C‡: XMLNode

Methods
std::string	name ()

ℕ Temporal

Methods
long	superclock_ticks_per_second ()

∁ Temporal:BBT_Argument

C‡: Temporal::BBT_Argument

is-a: Temporal:BBT_TIME

Bar, Beat, Tick Time (i.e. Tempo-Based Time)

Constructor
ℂ	Temporal.BBT_Argument (int, int, int)

Inherited from Temporal:BBT_TIME

Constructor
ℂ	Temporal.BBT_TIME (int, int, int)
Methods
std::string	str ()
Data Members
int	bars
int	beats
int	ticks

∁ Temporal:BBT_Offset

C‡: Temporal::BBT_Offset

Constructor
ℂ	Temporal.BBT_Offset (unsigned int, unsigned int, unsigned int)
Methods
std::string	str ()
Data Members
int	bars
int	beats
int	ticks

∁ Temporal:BBT_TIME

C‡: Temporal::BBT_Time

Bar, Beat, Tick Time (i.e. Tempo-Based Time)

Constructor
ℂ	Temporal.BBT_TIME (int, int, int)
Methods
std::string	str ()
Data Members
int	bars
int	beats
int	ticks

∁ Temporal:Beats

C‡: Temporal::Beats

Musical time in beats.

Constructor
ℂ	Temporal.Beats (int, int)
Methods
Beats	beats (long)
Beats	diff (Beats)
Beats	from_double (double)
long	get_beats ()
int	get_ticks ()
Beats	next_beat ()
Beats	prev_beat ()
Beats	round_down_to_beat ()
Beats	round_to_beat ()
Beats	round_up_to_beat ()
std::string	str ()
Beats	ticks (long)
long	to_ticks ()

∁ Temporal:Meter

C‡: Temporal::Meter

Meter, or time signature (subdivisions per bar, and which note type is a single subdivision).

Constructor
ℂ	Temporal.Meter (double, double)
Methods
int	divisions_per_bar ()
int	note_value ()

∁ Temporal:MeterPoint

C‡: Temporal::MeterPoint

is-a: Temporal:Meter

Meter, or time signature (subdivisions per bar, and which note type is a single subdivision).

Cast
Point	to_point ()

Inherited from Temporal:Meter

Constructor
ℂ	Temporal.Meter (double, double)
Methods
int	divisions_per_bar ()
int	note_value ()

∁ Temporal:Point

C‡: Temporal::Point

Methods
BBT_TIME	bbt ()
Beats	beats ()
long	sample (int)
long	sclock ()
timepos_t	time ()

∁ Temporal:Tempo

C‡: Temporal::Tempo

Tempo, the speed at which musical time progresses (BPM).

Constructor
ℂ	Temporal.Tempo (double, double, int)
Methods
int	note_type ()
double	note_types_per_minute ()
double	quarter_notes_per_minute ()
double	samples_per_note_type (int)
double	samples_per_quarter_note (int)
long	superclocks_per_note_type ()

↠ Temporal:TempoMap

C‡: std::shared_ptr< Temporal::TempoMap >, std::weak_ptr< Temporal::TempoMap >

Base class for objects with saveable and undoable state with destruction notification

Methods
void	abort_update ()
BBT_Argument	bbt_at (timepos_t)
BBT_Argument	bbt_at_beats (Beats)
timecnt_t	bbt_duration_at (timepos_t, BBT_Offset)
BBT_Argument	bbt_walk (BBT_Argument, BBT_Offset)
Beats	bbtwalk_to_quarters (Beats, BBT_Offset)
Beats	bbtwalk_to_quarters_bbt (BBT_Argument, BBT_Offset)
timecnt_t	convert_duration (timecnt_t, timepos_t, TimeDomain)
LuaTable(.…)	grid (TempoMapPoints&, long, long, unsigned int, unsigned int)
bool	isnil ()
MeterPoint	meter_at (timepos_t)
MeterPoint	meter_at_bbt (BBT_Argument)
MeterPoint	meter_at_beats (Beats)
MeterPoint	meter_at_sc (long)
LuaTable(.…)	midi_clock_beat_at_or_after (long, long&, unsigned int&)
Beats	quarters_at (timepos_t)
Beats	quarters_at_bbt (BBT_Argument)
Beats	quarters_at_sample (long)
double	quarters_per_minute_at (timepos_t)
TempoMap	read ()
BBT_Argument	round_to_bar (BBT_Argument)
long	sample_at (timepos_t)
long	sample_at_bbt (Beats)
long	sample_at_beats (Beats)
bool	set_continuing (TempoPoint&, bool)
MeterPoint	set_meter (Meter, timepos_t)
bool	set_ramped (TempoPoint&, bool)
TempoPoint	set_tempo (Tempo, timepos_t)
long	superclock_at (timepos_t)
long	superclock_at_bbt (BBT_Argument)
long	superclock_at_beats (Beats)
TempoPoint	tempo_at (timepos_t)
TempoPoint	tempo_at_bbt (BBT_Argument)
TempoPoint	tempo_at_beats (Beats)
TempoPoint	tempo_at_sc (long)
int	update (TempoMap)
TempoMap	write_copy ()

∁ Temporal:TempoMapPoint

C‡: Temporal::TempoMapPoint

is-a: Temporal:Point

Tempo Map - mapping of timecode to musical time. convert audio-samples, sample-rate to Bar/Beat/Tick, Meter/Tempo

Methods
timepos_t	time ()
Cast
TempoMetric	to_tempometric ()

Inherited from Temporal:Point

Methods
BBT_TIME	bbt ()
Beats	beats ()
long	sample (int)
long	sclock ()

∁ Temporal:TempoMapPoints

C‡: std::vector<Temporal::TempoMapPoint >

Constructor
ℂ	Temporal.TempoMapPoints ()
ℂ	Temporal.TempoMapPoints ()
Methods
LuaTable	add (LuaTable {TempoMapPoint})
TempoMapPoint	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (TempoMapPoint)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ Temporal:TempoMetric

C‡: Temporal::TempoMetric

Helper class to perform computations that require both Tempo and Meter at a given point in time.

It may seem nicer to make this IS-A TempoPoint and IS-A MeterPoint. Doing so runs into multiple inheritance of Point, plus the major semantic issue that pairing a tempo and a meter does in fact allow for two positions, not one. That means we have to provide accessors to the TempoPoint and MeterPoint and thus it may as well be HAS-A rather than IS-A.

This object should always be short lived. It holds references to a TempoPoint and a MeterPoint that are not lifetime-managed. It’s just a convenience object, in essence, to avoid having to replicate the computation code that requires both tempo and meter information every place it is used.

Methods
int	divisions_per_bar ()
MeterPoint	meter ()
int	note_type ()
int	note_value ()
Beats	quarters_at (BBT_TIME)
long	sample_at (Beats)
TempoPoint	tempo ()

∁ Temporal:TempoPoint

C‡: Temporal::TempoPoint

is-a: Temporal:Tempo

Tempo, the speed at which musical time progresses (BPM).

Methods
Beats	quarters_at_sample (long)
timepos_t	time ()
Cast
Point	to_point ()
Tempo	to_tempo ()

Inherited from Temporal:Tempo

Constructor
ℂ	Temporal.Tempo (double, double, int)
Methods
int	note_type ()
double	note_types_per_minute ()
double	quarter_notes_per_minute ()
double	samples_per_note_type (int)
double	samples_per_quarter_note (int)
long	superclocks_per_note_type ()

∁ Temporal:ratio

C‡: Temporal::_ratio_t<long>

Constructor
ℂ	Temporal.ratio (long, long)
Methods
bool	is_unity ()
bool	is_zero ()

∁ Temporal:timecnt_t

C‡: Temporal::timecnt_t

Constructor
ℂ	Temporal.timecnt_t (long)
Methods
timecnt_t	abs ()
Beats	beats ()
timecnt_t	decrement ()
timecnt_t	from_samples (long)
timecnt_t	from_superclock (long)
timecnt_t	from_ticks (long)
bool	is_negative ()
bool	is_positive ()
bool	is_zero ()
long	magnitude ()
timecnt_t	max ()
timepos_t	position ()
long	samples ()
timecnt_t	scale (ratio)
timecnt_t	scale (ratio)
void	set_position (timepos_t)
void	set_time_domain (TimeDomain)
std::string	str ()
long	superclocks ()
long	ticks ()
TimeDomain	time_domain ()
timecnt_t	zero (TimeDomain)

∁ Temporal:timepos_t

C‡: Temporal::timepos_t

Constructor
ℂ	Temporal.timepos_t (long)
Methods
Beats	beats ()
timepos_t	decrement ()
timecnt_t	distance (timepos_t)
timepos_t	from_superclock (long)
timepos_t	from_ticks (long)
timepos_t	increment ()
bool	is_beats ()
bool	is_negative ()
bool	is_positive ()
bool	is_superclock ()
bool	is_zero ()
timepos_t	max (TimeDomain)
long	samples ()
timepos_t	scale (ratio)
timepos_t	smallest_step (TimeDomain)
std::string	str ()
long	superclocks ()
long	ticks ()
TimeDomain	time_domain ()
timepos_t	zero (bool)

∁ Timecode:Time

C‡: Timecode::Time

Constructor
ℂ	[Timecode. Time]{.functionname}[ ([double]{ .em})]{.functionargs}
Data Members
[bool]{.em}	[drop]{.functionname}
	::: dox Whether this Time uses dropframe Timecode ::
[unsigned int]{.em}	[f rames]{.functionname}
	::: dox Timecode frames (not audio frames) ::
[unsigned int]{.em}	[ hours]{.functionname}
[unsigned int]{.em}	[mi nutes]{.functionname}
[bool]{.em}	[neg ative]{.functionname}
[double]{.em}	[rate]{.functionname}
	::: dox Frame rate of this Time ::
[unsigned int]{.em}	[se conds]{.functionname}
[unsigned int]{.em}	[subf rames]{.functionname}
	::: dox Typically unused ::

∁ Vamp:Plugin

C‡: Vamp::Plugin

is-a: Vamp:PluginBase

Vamp::Plugin is a base class for plugin instance classes that provide feature extraction from audio or related data.

In most cases, the input will be audio and the output will be a stream of derived data at a lower sampling resolution than the input.

Note that this class inherits several abstract methods from PluginBase. These must be implemented by the subclass.

PLUGIN LIFECYCLE

Feature extraction plugins are managed differently from real-time plugins (such as VST effects). The main difference is that the parameters for a feature extraction plugin are configured before the plugin is used, and do not change during use.

1. Host constructs the plugin, passing it the input sample rate. The plugin may do basic initialisation, but should not do anything computationally expensive at this point. You must make sure your plugin is cheap to construct, otherwise you’ll seriously affect the startup performance of almost all hosts. If you have serious initialisation to do, the proper place is in initialise() (step 5).

2. Host may query the plugin’s available outputs.

3. Host queries programs and parameter descriptors, and may set some or all of them. Parameters that are not explicitly set should take their default values as specified in the parameter descriptor. When a program is set, the parameter values may change and the host will re-query them to check.

4. Host queries the preferred step size, block size and number of channels. These may all vary depending on the parameter values. (Note however that you cannot make the number of distinct outputs dependent on parameter values.)

5. Plugin is properly initialised with a call to initialise. This fixes the step size, block size, and number of channels, as well as all of the parameter and program settings. If the values passed in to initialise do not match the plugin’s advertised preferred values from step 4, the plugin may refuse to initialise and return false (although if possible it should accept the new values). Any computationally expensive setup code should take place here.

6. Host finally checks the number of values, resolution, extents etc per output (which may vary depending on the number of channels, step size and block size as well as the parameter values).

7. Host will repeatedly call the process method to pass in blocks of input data. This method may return features extracted from that data (if the plugin is causal).

8. Host will call getRemainingFeatures exactly once, after all the input data has been processed. This may return any non-causal or leftover features.

9. At any point after initialise was called, the host may optionally call the reset method and restart processing. (This does not mean it can change the parameters, which are fixed from initialise until destruction.)

A plugin does not need to handle the case where setParameter or selectProgram is called after initialise has been called. It’s the host’s responsibility not to do that. Similarly, the plugin may safely assume that initialise is called no more than once.

Methods
[InputDomain](#Vam p.Plugin.InputDomain)	[getInputDo main]{.functionname}[ ()]{.functionargs}
	::: dox Get the plugin's required input domain. If this is TimeDomain, the samples provided to the process() function (below) will be in the time domain, as for a traditional audio processing plugin. If this is FrequencyDomain, the host will carry out a windowed FFT of size equal to the negotiated block size on the data before passing the frequency bin data in to process(). The input data for the FFT will be rotated so as to place the origin in the centre of the block. The plugin does not get to choose the window type -- the host will either let the user do so, or will use a Hanning window. ::
[unsigned long]{.em}	[getMaxChannelC ount]{.functionname}[ ()]{.functionargs}
	::: dox Get the maximum supported number of input channels. ::
[unsigned long]{.em}	[getMinChannelC ount]{.functionname}[ ()]{.functionargs}
	::: dox Get the minimum supported number of input channels. ::
[OutputList](#Va mp:Plugin:OutputList)	[getOutputDescrip tors]{.functionname}[ ()]{.functionargs}
	::: dox Get the outputs of this plugin. An output's index in this list is used as its numeric index when looking it up in the FeatureSet returned from the process() call. ::
[unsigned long]{.em}	[getPreferredBlock Size]{.functionname}[ ()]{.functionargs}
	::: dox Get the preferred block size (window size -- the number of sample frames passed in each block to the process() function). This should be called before initialise(). A plugin that can handle any block size may return 0. The final block size will be set in the initialise() call. ::
[unsigned long]{.em}	[getPreferredStep Size]{.functionname}[ ()]{.functionargs}
	::: dox Get the preferred step size (window increment -- the distance in sample frames between the start frames of consecutive blocks passed to the process() function) for the plugin. This should be called before initialise(). A plugin may return 0 if it has no particular interest in the step size. In this case, the host should make the step size equal to the block size if the plugin is accepting input in the time domain. If the plugin is accepting input in the frequency domain, the host may use any step size. The final step size will be set in the initialise() call. ::
[FeatureSet](#Va mp:Plugin:FeatureSet)	[getRemainingFeat ures]{.functionname}[ ()]{.functionargs}
	::: dox After all blocks have been processed, calculate and return any remaining features derived from the complete input. ::
[std::string]{.em}	[get Type]{.functionname}[ ()]{.functionargs}
	::: dox Used to distinguish between Vamp::Plugin and other potential sibling subclasses of PluginBase. Do not reimplement this function in your subclass. ::
[bool]{.em}	[initia lise]{.functionname}[ ([unsigned long]{.em}, [unsigned long]{.em}, [unsigned long]{ .em})]{.functionargs}
	::: dox Initialise a plugin to prepare it for use with the given number of input channels, step size (window increment, in sample frames) and block size (window size, in sample frames). The input sample rate should have been already specified at construction time. Return true for successful initialisation, false if the number of input channels, step size and/or block size cannot be supported. ::
[void]{.em}	[r eset]{.functionname}[ ()]{.functionargs}
	::: dox Reset the plugin after use, to prepare it for another clean run. Not called for the first initialisation (i.e. initialise must also do a reset). ::

Inherited from Vamp:PluginBase

Methods
[std::string]{.em}	[getCopyr ight]{.functionname}[ ()]{.functionargs}
	::: dox Get the copyright statement or licensing summary for the plugin. This can be an informative text, without the same presentation constraints as mentioned for getMaker above. ::
[std::string]{.em}	[getCurrentPro gram]{.functionname}[ ()]{.functionargs}
	::: dox Get the current program. ::
[std::string]{.em}	[getDescrip tion]{.functionname}[ ()]{.functionargs}
	::: dox Get a human-readable description for the plugin, typically a line of text that may optionally be displayed in addition to the plugin's "name". May be empty if the name has said it all already. Example: "Detect and count zero crossing points" ::
[std::string]{.em}	[getIdenti fier]{.functionname}[ ()]{.functionargs}
	::: dox Get the computer-usable name of the plugin. This should be reasonably short and contain no whitespace or punctuation characters. It may only contain the characters [a-zA-Z0-9_-]. This is the authoritative way for a program to identify a plugin within a given library. This text may be visible to the user, but it should not be the main text used to identify a plugin to the user (that will be the name, below). Example: "zero_crossings" ::
[std::string]{.em}	[getM aker]{.functionname}[ ()]{.functionargs}
	::: dox Get the name of the author or vendor of the plugin in human-readable form. This should be a short identifying text, as it may be used to label plugins from the same source in a menu or similar. ::
[std::string]{.em}	[get Name]{.functionname}[ ()]{.functionargs}
	::: dox Get a human-readable name or title of the plugin. This should be brief and self-contained, as it may be used to identify the plugin to the user in isolation (i.e. without also showing the plugin's "identifier"). Example: "Zero Crossings" ::
[float]{.em}	[getParam eter]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Get the value of a named parameter. The argument is the identifier field from that parameter's descriptor. ::
[Para meterList](#Vamp:Plug inBase:ParameterList)	[getParameterDescrip tors]{.functionname}[ ()]{.functionargs}
	::: dox Get the controllable parameters of this plugin. ::
[int]{.em}	[getPluginVer sion]{.functionname}[ ()]{.functionargs}
	::: dox Get the version number of the plugin. ::
[StringVec tor](#C:StringVector)	[getProg rams]{.functionname}[ ()]{.functionargs}
	::: dox Get the program settings available in this plugin. A program is a named shorthand for a set of parameter values; changing the program may cause the plugin to alter the values of its published parameters (and/or non-public internal processing parameters). The host should re-read the plugin's parameter values after setting a new program. The programs must have unique names. ::
[void]{.em}	[selectPro gram]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Select a program. (If the given program name is not one of the available programs, do nothing.) ::
[void]{.em}	[setParam eter]{.functionname}[ ([std::string]{.em}, [float]{ .em})]{.functionargs}
	::: dox Set a named parameter. The first argument is the identifier field from that parameter's descriptor. ::

∁ Vamp:Plugin:Feature

C‡: Vamp::Plugin::Feature

Data Members
[Vamp:Real Time](#Vamp:RealTime)	[dur ation]{.functionname}
	::: dox Duration of the output feature. This is mandatory if the output has VariableSampleRate or FixedSampleRate and hasDuration is true, and unused otherwise. ::
[bool]{.em}	[hasDur ation]{.functionname}
	::: dox True if an output feature has a specified duration. This is optional if the output has VariableSampleRate or FixedSampleRate, and and unused if the output has OneSamplePerStep. ::
[bool]{.em}	[hasTime stamp]{.functionname}
	::: dox True if an output feature has its own timestamp. This is mandatory if the output has VariableSampleRate, optional if the output has FixedSampleRate, and unused if the output has OneSamplePerStep. ::
[std::string]{.em}	[ label]{.functionname}
	::: dox Label for the sample of this feature. ::
[Vamp:Real Time](#Vamp:RealTime)	[time stamp]{.functionname}
	::: dox Timestamp of the output feature. This is mandatory if the output has VariableSampleRate or if the output has FixedSampleRate and hasTimestamp is true, and unused otherwise. ::
[C:FloatVe ctor](#C:FloatVector)	[v alues]{.functionname}
	::: dox Results for a single sample of this feature. If the output hasFixedBinCount, there must be the same number of values as the output's binCount count. ::

∁ Vamp:Plugin:FeatureList

C‡: std::vector<Vamp::Plugin::Feature >

Constructor
ℂ	Vamp.Plugin.FeatureList ()
ℂ	Vamp.Plugin.FeatureList ()
Methods
LuaTable	add (LuaTable {Feature})
Feature	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (Feature)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ Vamp:Plugin:FeatureSet

C‡: std::map<int, std::vector<Vamp::Plugin::Feature > > > >

Constructor
ℂ	Vamp.Plugin.FeatureSet ()
Methods
LuaTable	add (LuaTable {Feature})
.…	at (–lua–)
void	clear ()
unsigned long	count (int)
bool	empty ()
LuaIter	iter ()
unsigned long	size ()
LuaTable	table ()

∁ Vamp:Plugin:OutputDescriptor

C‡: Vamp::Plugin::OutputDescriptor

Data Members
[unsigned long]{.em}	[bin Count]{.functionname}
	::: dox The number of values per result of the output. Undefined if hasFixedBinCount is false. If this is zero, the output is point data (i.e. only the time of each output is of interest, the value list will be empty). ::
[C:StringVec tor](#C:StringVector)	[bin Names]{.functionname}
	::: dox The (human-readable) names of each of the bins, if appropriate. This is always optional. ::
[std::string]{.em}	[descri ption]{.functionname}
	::: dox A human-readable short text describing the output. May be empty if the name has said it all already. Example: "The number of zero crossing points per processing block" ::
[bool]{.em}	[hasDur ation]{.functionname}
	::: dox True if the returned results for this output are known to have a duration field. ::
[bool]{.em}	[hasFixedBin Count]{.functionname}
	::: dox True if the output has the same number of values per sample for every output sample. Outputs for which this is false are unlikely to be very useful in a general-purpose host. ::
[bool]{.em}	[hasKnownEx tents]{.functionname}
	::: dox True if the results in each output bin fall within a fixed numeric range (minimum and maximum values). Undefined if binCount is zero. ::
[std::string]{.em}	[ident ifier]{.functionname}
	::: dox The name of the output, in computer-usable form. Should be reasonably short and without whitespace or punctuation, using the characters [a-zA-Z0-9_-] only. Example: " zero_crossing_count" ::
[bool]{.em}	[isQuan tized]{.functionname}
	::: dox True if the output values are quantized to a particular resolution. Undefined if binCount is zero. ::
[float]{.em}	[max Value]{.functionname}
	::: dox Maximum value of the results in the output. Undefined if hasKnownExtents is false or binCount is zero. ::
[float]{.em}	[min Value]{.functionname}
	::: dox Minimum value of the results in the output. Undefined if hasKnownExtents is false or binCount is zero. ::
[float]{.em}	[quantiz eStep]{.functionname}
	::: dox Quantization resolution of the output values (e.g. 1.0 if they are all integers). Undefined if isQuantized is false or binCount is zero. ::
[float]{.em}	[sampl eRate]{.functionname}
	::: dox Sample rate of the output results, as samples per second. Undefined if sampleType is OneSamplePerStep. If sampleType is VariableSampleRate and this value is non-zero, then it may be used to calculate a resolution for the output (i.e. the "duration" of each sample, in time, will be 1/sampleRate seconds). It's recommended to set this to zero if that behaviour is not desired. ::
[Vamp.Plugin.OutputD escriptor.SampleType] (#Vamp.Plugin.OutputD escriptor.SampleType)	[sampl eType]{.functionname}
	::: dox Positioning in time of the output results. ::
[std::string]{.em}	[unit]{.functionname}
	::: dox The unit of the output, in human-readable form. ::

∁ Vamp:Plugin:OutputList

C‡: std::vector<Vamp::Plugin::OutputDescriptor >

Constructor
ℂ	Vamp.Plugin.OutputList ()
ℂ	Vamp.Plugin.OutputList ()
Methods
LuaTable	add (LuaTable {OutputDescriptor})
OutputDescriptor	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (OutputDescriptor)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ Vamp:PluginBase

C‡: Vamp::PluginBase

A base class for plugins with optional configurable parameters, programs, etc. The Vamp::Plugin is derived from this, and individual Vamp plugins should derive from that.

This class does not provide the necessary interfaces to instantiate or run a plugin. It only specifies an interface for retrieving those controls that the host may wish to show to the user for editing. It could meaningfully be subclassed by real-time plugins or other sorts of plugin as well as Vamp plugins.

Methods
[std::string]{.em}	[getCopyr ight]{.functionname}[ ()]{.functionargs}
	::: dox Get the copyright statement or licensing summary for the plugin. This can be an informative text, without the same presentation constraints as mentioned for getMaker above. ::
[std::string]{.em}	[getCurrentPro gram]{.functionname}[ ()]{.functionargs}
	::: dox Get the current program. ::
[std::string]{.em}	[getDescrip tion]{.functionname}[ ()]{.functionargs}
	::: dox Get a human-readable description for the plugin, typically a line of text that may optionally be displayed in addition to the plugin's "name". May be empty if the name has said it all already. Example: "Detect and count zero crossing points" ::
[std::string]{.em}	[getIdenti fier]{.functionname}[ ()]{.functionargs}
	::: dox Get the computer-usable name of the plugin. This should be reasonably short and contain no whitespace or punctuation characters. It may only contain the characters [a-zA-Z0-9_-]. This is the authoritative way for a program to identify a plugin within a given library. This text may be visible to the user, but it should not be the main text used to identify a plugin to the user (that will be the name, below). Example: "zero_crossings" ::
[std::string]{.em}	[getM aker]{.functionname}[ ()]{.functionargs}
	::: dox Get the name of the author or vendor of the plugin in human-readable form. This should be a short identifying text, as it may be used to label plugins from the same source in a menu or similar. ::
[std::string]{.em}	[get Name]{.functionname}[ ()]{.functionargs}
	::: dox Get a human-readable name or title of the plugin. This should be brief and self-contained, as it may be used to identify the plugin to the user in isolation (i.e. without also showing the plugin's "identifier"). Example: "Zero Crossings" ::
[float]{.em}	[getParam eter]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Get the value of a named parameter. The argument is the identifier field from that parameter's descriptor. ::
[Para meterList](#Vamp:Plug inBase:ParameterList)	[getParameterDescrip tors]{.functionname}[ ()]{.functionargs}
	::: dox Get the controllable parameters of this plugin. ::
[int]{.em}	[getPluginVer sion]{.functionname}[ ()]{.functionargs}
	::: dox Get the version number of the plugin. ::
[StringVec tor](#C:StringVector)	[getProg rams]{.functionname}[ ()]{.functionargs}
	::: dox Get the program settings available in this plugin. A program is a named shorthand for a set of parameter values; changing the program may cause the plugin to alter the values of its published parameters (and/or non-public internal processing parameters). The host should re-read the plugin's parameter values after setting a new program. The programs must have unique names. ::
[std::string]{.em}	[get Type]{.functionname}[ ()]{.functionargs}
	::: dox Get the type of plugin. This is to be implemented by the immediate subclass, not by actual plugins. Do not attempt to implement this in plugin code. ::
[void]{.em}	[selectPro gram]{.functionname}[ ([std::string]{ .em})]{.functionargs}
	::: dox Select a program. (If the given program name is not one of the available programs, do nothing.) ::
[void]{.em}	[setParam eter]{.functionname}[ ([std::string]{.em}, [float]{ .em})]{.functionargs}
	::: dox Set a named parameter. The first argument is the identifier field from that parameter's descriptor. ::

∁ Vamp:PluginBase:ParameterDescriptor

C‡: Vamp::PluginBase::ParameterDescriptor

Data Members
[float]{.em}	[default Value]{.functionname}
	::: dox The default value of the parameter. The plugin should ensure that parameters have this value on initialisation (i.e. the host is not required to explicitly set parameters if it wants to use their default values). ::
[std::string]{.em}	[descri ption]{.functionname}
	::: dox A human-readable short text describing the parameter. May be empty if the name has said it all already. ::
[std::string]{.em}	[ident ifier]{.functionname}
	::: dox The name of the parameter, in computer-usable form. Should be reasonably short, and may only contain the characters [a-zA-Z0-9_-]. ::
[bool]{.em}	[isQuan tized]{.functionname}
	::: dox True if the parameter values are quantized to a particular resolution. ::
[float]{.em}	[max Value]{.functionname}
	::: dox The maximum value of the parameter. ::
[float]{.em}	[min Value]{.functionname}
	::: dox The minimum value of the parameter. ::
[std::string]{.em}	[name]{.functionname}
	::: dox The human-readable name of the parameter. ::
[float]{.em}	[quantiz eStep]{.functionname}
	::: dox Quantization resolution of the parameter values (e.g. 1.0 if they are all integers). Undefined if isQuantized is false. ::
[std::string]{.em}	[unit]{.functionname}
	::: dox The unit of the parameter, in human-readable form. ::
[C:StringVec tor](#C:StringVector)	[value Names]{.functionname}
	::: dox Names for the quantized values. If isQuantized is true, this may either be empty or contain one string for each of the quantize steps from minValue up to maxValue inclusive. Undefined if isQuantized is false. If these names are provided, they should be shown to the user in preference to the values themselves. The user may never see the actual numeric values unless they are also encoded in the names. ::

∁ Vamp:PluginBase:ParameterList

C‡: std::vector<Vamp::PluginBase::ParameterDescriptor >

Constructor
ℂ	Vamp.PluginBase.ParameterList ()
ℂ	Vamp.PluginBase.ParameterList ()
Methods
LuaTable	add (LuaTable {ParameterDescriptor})
ParameterDescriptor	at (unsigned long)
void	clear ()
bool	empty ()
LuaIter	iter ()
void	push_back (ParameterDescriptor)
void	reserve (unsigned long)
unsigned long	size ()
LuaTable	table ()
.…	to_array (–lua–)

∁ Vamp:RealTime

C‡: Vamp::RealTime

RealTime represents time values to nanosecond precision with accurate arithmetic and frame-rate conversion functions.

Constructor
ℂ	[Vamp.Real Time]{.functionname}[ ([int]{.em}, [int]{ .em})]{.functionargs}
Methods
[Real Time](#Vamp:RealTime)	[frame2Real Time]{.functionname}[ ([long]{.em}, [unsigned int]{ .em})]{.functionargs}
[int]{.em}	[ msec]{.functionname}[ ()]{.functionargs}
[long]{.em}	[realTime2F rame]{.functionname}[ ([RealT ime](#Vamp:RealTime), [unsigned int]{ .em})]{.functionargs}
[std::string]{.em}	[toSt ring]{.functionname}[ ()]{.functionargs}
	::: dox Return a human-readable debug-type string to full precision (probably not a format to show to a user directly) ::
[int]{.em}	[ usec]{.functionname}[ ()]{.functionargs}
Data Members
[int]{.em}	[nsec]{.functionname}
[int]{.em}	[sec]{.functionname}

ℕ os

Methods
int	execute (std::string)
LuaTable	forkexec ()

Enum/Constants

∈ PBD.Controllable.GroupControlDisposition

{#PBD.Controllable.GroupControlDisposition .cls .enum}

• PBD.GroupControlDisposition.InverseGroup

• PBD.GroupControlDisposition.NoGroup

• PBD.GroupControlDisposition.UseGroup

∈ Timecode.TimecodeFormat

{#Timecode.TimecodeFormat .cls .enum}

• Timecode.TimecodeFormat.TC23976

• Timecode.TimecodeFormat.TC24

• Timecode.TimecodeFormat.TC24976

• Timecode.TimecodeFormat.TC25

• Timecode.TimecodeFormat.TC2997

• Timecode.TimecodeFormat.TC2997DF

• Timecode.TimecodeFormat.TC2997000

• Timecode.TimecodeFormat.TC2997000DF

• Timecode.TimecodeFormat.TC30

• Timecode.TimecodeFormat.TC5994

• Timecode.TimecodeFormat.TC60

∈ Temporal

• Temporal.ticks_per_beat

∈ Temporal.TimeDomain

{#Temporal.TimeDomain .cls .enum}

• Temporal.TimeDomain.AudioTime

• Temporal.TimeDomain.BeatTime

∈ Temporal.Tempo.Type

{#Temporal.Tempo.Type .cls .enum}

• Temporal.Tempo.Type.Ramp

• Temporal.Tempo.Type.Constant

∈ Evoral.ControlList.InterpolationStyle

{#Evoral.ControlList.InterpolationStyle .cls .enum}

• Evoral.InterpolationStyle.Discrete

• Evoral.InterpolationStyle.Linear

• Evoral.InterpolationStyle.Curved

• Evoral.InterpolationStyle.Logarithmic

• Evoral.InterpolationStyle.Exponential

∈ Evoral.EventType

{#Evoral.EventType .cls .enum}

• Evoral.EventType.NO_EVENT

• Evoral.EventType.MIDI_EVENT

• Evoral.EventType.LIVE_MIDI_EVENT

∈ Vamp.Plugin.InputDomain

{#Vamp.Plugin.InputDomain .cls .enum}

• Vamp.Plugin.InputDomain.TimeDomain

• Vamp.Plugin.InputDomain.FrequencyDomain

∈ Vamp.Plugin.OutputDescriptor.SampleType

{#Vamp.Plugin.OutputDescriptor.SampleType .cls .enum}

• Vamp.Plugin.OutputDescriptor.SampleType.OneSamplePerStep

• Vamp.Plugin.OutputDescriptor.SampleType.FixedSampleRate

• Vamp.Plugin.OutputDescriptor.SampleType.VariableSampleRate

∈ ARDOUR

• ARDOUR.revision

∈ ARDOUR.ChanMapping

{#ARDOUR.ChanMapping .cls .enum}

• ARDOUR.ChanMapping.Invalid

∈ PBD.PropertyDescriptor<Temporal.timepos_t>*

{#PBD.PropertyDescriptor<Temporal.timepos_t>* .cls .enum}

• ARDOUR.Properties.Start

∈ PBD.PropertyDescriptor<Temporal.timecnt_t>*

{#PBD.PropertyDescriptor<Temporal.timecnt_t>* .cls .enum}

• ARDOUR.Properties.Length

∈ PBD.PropertyDescriptor<unsigned int>*

{#PBD.PropertyDescriptor* .cls .enum}

• ARDOUR.Properties.Layer

∈ PBD.PropertyDescriptor<bool>*

{#PBD.PropertyDescriptor* .cls .enum}

• ARDOUR.Properties.Muted

• ARDOUR.Properties.Opaque

∈ ARDOUR.PresentationInfo

{#ARDOUR.PresentationInfo .cls .enum}

• ARDOUR.PresentationInfo.max_order

∈ ARDOUR.PluginType

{#ARDOUR.PluginType .cls .enum}

• ARDOUR.PluginType.AudioUnit

• ARDOUR.PluginType.LADSPA

• ARDOUR.PluginType.LV2

• ARDOUR.PluginType.Windows_VST

• ARDOUR.PluginType.LXVST

• ARDOUR.PluginType.MacVST

• ARDOUR.PluginType.Lua

• ARDOUR.PluginType.VST3

∈ ARDOUR.PresentationInfo.Flag

{#ARDOUR.PresentationInfo.Flag .cls .enum}

• ARDOUR.PresentationInfo.Flag.AudioTrack

• ARDOUR.PresentationInfo.Flag.MidiTrack

• ARDOUR.PresentationInfo.Flag.AudioBus

• ARDOUR.PresentationInfo.Flag.MidiBus

• ARDOUR.PresentationInfo.Flag.VCA

• ARDOUR.PresentationInfo.Flag.MasterOut

• ARDOUR.PresentationInfo.Flag.MonitorOut

• ARDOUR.PresentationInfo.Flag.Auditioner

• ARDOUR.PresentationInfo.Flag.Hidden

• ARDOUR.PresentationInfo.Flag.GroupOrderSet

• ARDOUR.PresentationInfo.Flag.TriggerTrack

• ARDOUR.PresentationInfo.Flag.StatusMask

• ARDOUR.PresentationInfo.Flag.TypeMask

∈ ARDOUR.AutoState

{#ARDOUR.AutoState .cls .enum}

• ARDOUR.AutoState.Off

• ARDOUR.AutoState.Write

• ARDOUR.AutoState.Touch

• ARDOUR.AutoState.Play

• ARDOUR.AutoState.Latch

∈ ARDOUR.AutomationType

{#ARDOUR.AutomationType .cls .enum}

• ARDOUR.AutomationType.GainAutomation

• ARDOUR.AutomationType.BusSendLevel

• ARDOUR.AutomationType.SurroundSendLevel

• ARDOUR.AutomationType.InsertReturnLevel

• ARDOUR.AutomationType.PluginAutomation

• ARDOUR.AutomationType.SoloAutomation

• ARDOUR.AutomationType.SoloIsolateAutomation

• ARDOUR.AutomationType.SoloSafeAutomation

• ARDOUR.AutomationType.MuteAutomation

• ARDOUR.AutomationType.RecEnableAutomation

• ARDOUR.AutomationType.RecSafeAutomation

• ARDOUR.AutomationType.TrimAutomation

• ARDOUR.AutomationType.PhaseAutomation

• ARDOUR.AutomationType.MidiCCAutomation

• ARDOUR.AutomationType.MidiPgmChangeAutomation

• ARDOUR.AutomationType.MidiPitchBenderAutomation

• ARDOUR.AutomationType.MidiChannelPressureAutomation

• ARDOUR.AutomationType.MidiNotePressureAutomation

• ARDOUR.AutomationType.MidiSystemExclusiveAutomation

∈ ARDOUR.SrcQuality

{#ARDOUR.SrcQuality .cls .enum}

• ARDOUR.SrcQuality.SrcBest

∈ ARDOUR.SectionOperation

{#ARDOUR.SectionOperation .cls .enum}

• ARDOUR.SectionOperation.CopyPaste

• ARDOUR.SectionOperation.CutPaste

• ARDOUR.SectionOperation.Insert

• ARDOUR.SectionOperation.Delete

∈ ARDOUR.MeterType

{#ARDOUR.MeterType .cls .enum}

• ARDOUR.MeterType.MeterMaxSignal

• ARDOUR.MeterType.MeterMaxPeak

• ARDOUR.MeterType.MeterPeak

• ARDOUR.MeterType.MeterKrms

• ARDOUR.MeterType.MeterK20

• ARDOUR.MeterType.MeterK14

• ARDOUR.MeterType.MeterIEC1DIN

• ARDOUR.MeterType.MeterIEC1NOR

• ARDOUR.MeterType.MeterIEC2BBC

• ARDOUR.MeterType.MeterIEC2EBU

• ARDOUR.MeterType.MeterVU

• ARDOUR.MeterType.MeterK12

• ARDOUR.MeterType.MeterPeak0dB

• ARDOUR.MeterType.MeterMCP

∈ ARDOUR.MeterPoint

{#ARDOUR.MeterPoint .cls .enum}

• ARDOUR.MeterPoint.MeterInput

• ARDOUR.MeterPoint.MeterPreFader

• ARDOUR.MeterPoint.MeterPostFader

• ARDOUR.MeterPoint.MeterOutput

• ARDOUR.MeterPoint.MeterCustom

∈ ARDOUR.Placement

{#ARDOUR.Placement .cls .enum}

• ARDOUR.Placement.PreFader

• ARDOUR.Placement.PostFader

∈ ARDOUR.MonitorChoice

{#ARDOUR.MonitorChoice .cls .enum}

• ARDOUR.MonitorChoice.MonitorAuto

• ARDOUR.MonitorChoice.MonitorInput

• ARDOUR.MonitorChoice.MonitorDisk

• ARDOUR.MonitorChoice.MonitorCue

∈ ARDOUR.MonitorState

{#ARDOUR.MonitorState .cls .enum}

• ARDOUR.MonitorState.MonitoringSilence

• ARDOUR.MonitorState.MonitoringInput

• ARDOUR.MonitorState.MonitoringDisk

• ARDOUR.MonitorState.MonitoringCue

∈ ARDOUR.FastWindOp

{#ARDOUR.FastWindOp .cls .enum}

• ARDOUR.FastWindOp.FastWindOff

• ARDOUR.FastWindOp.FastWindVarispeed

• ARDOUR.FastWindOp.FastWindLocate

∈ ARDOUR.MuteMaster.MutePoint

{#ARDOUR.MuteMaster.MutePoint .cls .enum}

• ARDOUR.MutePoint.PreFader

• ARDOUR.MutePoint.PostFader

• ARDOUR.MutePoint.Listen

• ARDOUR.MutePoint.Main

∈ ARDOUR.NoteMode

{#ARDOUR.NoteMode .cls .enum}

• ARDOUR.NoteMode.Sustained

• ARDOUR.NoteMode.Percussive

∈ ARDOUR.ChannelMode

{#ARDOUR.ChannelMode .cls .enum}

• ARDOUR.ChannelMode.AllChannels

• ARDOUR.ChannelMode.FilterChannels

• ARDOUR.ChannelMode.ForceChannel

∈ ARDOUR.PortFlags

{#ARDOUR.PortFlags .cls .enum}

• ARDOUR.PortFlags.IsInput

• ARDOUR.PortFlags.IsOutput

• ARDOUR.PortFlags.IsPhysical

• ARDOUR.PortFlags.CanMonitor

• ARDOUR.PortFlags.IsTerminal

∈ ARDOUR.MidiPortFlags

{#ARDOUR.MidiPortFlags .cls .enum}

• ARDOUR.MidiPortFlags.MidiPortMusic

• ARDOUR.MidiPortFlags.MidiPortControl

• ARDOUR.MidiPortFlags.MidiPortSelection

• ARDOUR.MidiPortFlags.MidiPortVirtual

∈ ARDOUR.PlaylistDisposition

{#ARDOUR.PlaylistDisposition .cls .enum}

• ARDOUR.PlaylistDisposition.CopyPlaylist

• ARDOUR.PlaylistDisposition.NewPlaylist

• ARDOUR.PlaylistDisposition.SharePlaylist

∈ ARDOUR.MidiTrackNameSource

{#ARDOUR.MidiTrackNameSource .cls .enum}

• ARDOUR.MidiTrackNameSource.SMFTrackNumber

• ARDOUR.MidiTrackNameSource.SMFTrackName

• ARDOUR.MidiTrackNameSource.SMFFileAndTrackName

• ARDOUR.MidiTrackNameSource.SMFInstrumentName

∈ ARDOUR.MidiTempoMapDisposition

{#ARDOUR.MidiTempoMapDisposition .cls .enum}

• ARDOUR.MidiTempoMapDisposition.SMFTempoIgnore

• ARDOUR.MidiTempoMapDisposition.SMFTempoUse

∈ ARDOUR.RegionEquivalence

{#ARDOUR.RegionEquivalence .cls .enum}

• ARDOUR.RegionEquivalence.Exact

• ARDOUR.RegionEquivalence.Enclosed

• ARDOUR.RegionEquivalence.Overlap

• ARDOUR.RegionEquivalence.LayerTime

∈ ARDOUR.RegionPoint

{#ARDOUR.RegionPoint .cls .enum}

• ARDOUR.RegionPoint.Start

• ARDOUR.RegionPoint.End

• ARDOUR.RegionPoint.SyncPoint

∈ ARDOUR.TrackMode

{#ARDOUR.TrackMode .cls .enum}

• ARDOUR.TrackMode.Normal

• ARDOUR.TrackMode.NonLayered

∈ ARDOUR.RecordMode

{#ARDOUR.RecordMode .cls .enum}

• ARDOUR.RecordMode.RecLayered

• ARDOUR.RecordMode.RecNonLayered

• ARDOUR.RecordMode.RecSoundOnSound

∈ ARDOUR.TransportRequestSource

{#ARDOUR.TransportRequestSource .cls .enum}

• ARDOUR.TransportRequestSource.TRS_Engine

• ARDOUR.TransportRequestSource.TRS_UI

∈ ARDOUR.LocateTransportDisposition

{#ARDOUR.LocateTransportDisposition .cls .enum}

• ARDOUR.LocateTransportDisposition.MustRoll

• ARDOUR.LocateTransportDisposition.MustStop

• ARDOUR.LocateTransportDisposition.RollIfAppropriate

∈ ARDOUR.CueBehavior

{#ARDOUR.CueBehavior .cls .enum}

• ARDOUR.CueBehavior.FollowCues

• ARDOUR.CueBehavior.ImplicitlyIgnoreCues

∈ ARDOUR.Session.RouteGroupImportMode

{#ARDOUR.Session.RouteGroupImportMode .cls .enum}

• ARDOUR.RouteGroupImportMode.IgnoreRouteGroup

• ARDOUR.RouteGroupImportMode.UseRouteGroup

• ARDOUR.RouteGroupImportMode.CreateRouteGroup

∈ ARDOUR.WellKnownCtrl

{#ARDOUR.WellKnownCtrl .cls .enum}

• ARDOUR.WellKnownCtrl.EQ_Enable

• ARDOUR.WellKnownCtrl.EQ_Mode

• ARDOUR.WellKnownCtrl.EQ_BandGain

• ARDOUR.WellKnownCtrl.EQ_BandFreq

• ARDOUR.WellKnownCtrl.EQ_BandQ

• ARDOUR.WellKnownCtrl.EQ_BandShape

• ARDOUR.WellKnownCtrl.HPF_Enable

• ARDOUR.WellKnownCtrl.HPF_Freq

• ARDOUR.WellKnownCtrl.HPF_Slope

• ARDOUR.WellKnownCtrl.LPF_Enable

• ARDOUR.WellKnownCtrl.LPF_Freq

• ARDOUR.WellKnownCtrl.LPF_Slope

• ARDOUR.WellKnownCtrl.TapeDrive_Drive

• ARDOUR.WellKnownCtrl.TapeDrive_Mode

• ARDOUR.WellKnownCtrl.Comp_Enable

• ARDOUR.WellKnownCtrl.Comp_Mode

• ARDOUR.WellKnownCtrl.Comp_Threshold

• ARDOUR.WellKnownCtrl.Comp_Makeup

• ARDOUR.WellKnownCtrl.Comp_Ratio

• ARDOUR.WellKnownCtrl.Comp_Attack

• ARDOUR.WellKnownCtrl.Comp_Release

• ARDOUR.WellKnownCtrl.Comp_KeyFilterFreq

• ARDOUR.WellKnownCtrl.Comp_Lookahead

• ARDOUR.WellKnownCtrl.Comp_FastAttack

• ARDOUR.WellKnownCtrl.Comp_Mix

• ARDOUR.WellKnownCtrl.Comp_RMSPeak

• ARDOUR.WellKnownCtrl.Gate_Enable

• ARDOUR.WellKnownCtrl.Gate_Mode

• ARDOUR.WellKnownCtrl.Gate_Threshold

• ARDOUR.WellKnownCtrl.Gate_Ratio

• ARDOUR.WellKnownCtrl.Gate_Knee

• ARDOUR.WellKnownCtrl.Gate_Depth

• ARDOUR.WellKnownCtrl.Gate_Hysteresis

• ARDOUR.WellKnownCtrl.Gate_Hold

• ARDOUR.WellKnownCtrl.Gate_Attack

• ARDOUR.WellKnownCtrl.Gate_Release

• ARDOUR.WellKnownCtrl.Gate_KeyListen

• ARDOUR.WellKnownCtrl.Gate_KeyFilterEnable

• ARDOUR.WellKnownCtrl.Gate_KeyFilterFreq

• ARDOUR.WellKnownCtrl.Gate_Lookahead

• ARDOUR.WellKnownCtrl.Gate_FastAttack

• ARDOUR.WellKnownCtrl.DeEss_Enable

• ARDOUR.WellKnownCtrl.DeEss_HiShelf

• ARDOUR.WellKnownCtrl.DeEss_Threshold

• ARDOUR.WellKnownCtrl.DeEss_Attack

• ARDOUR.WellKnownCtrl.DeEss_EssDepth

• ARDOUR.WellKnownCtrl.DeEss_EssFreq

• ARDOUR.WellKnownCtrl.DeEss_EssSolo

• ARDOUR.WellKnownCtrl.DeEss_HiDepth

• ARDOUR.WellKnownCtrl.DeEss_HiFreq

• ARDOUR.WellKnownCtrl.DeEss_HiSolo

• ARDOUR.WellKnownCtrl.Denoise_Enable

• ARDOUR.WellKnownCtrl.Denoise_Threshold

• ARDOUR.WellKnownCtrl.Denoise_DepthLow

• ARDOUR.WellKnownCtrl.Denoise_DepthHigh

• ARDOUR.WellKnownCtrl.Master_Limiter_Enable

∈ ARDOUR.WellKnownData

{#ARDOUR.WellKnownData .cls .enum}

• ARDOUR.WellKnownData.TapeDrive_Saturation

• ARDOUR.WellKnownData.Master_PhaseCorrelationMin

• ARDOUR.WellKnownData.Master_PhaseCorrelationMax

• ARDOUR.WellKnownData.Master_KMeter

• ARDOUR.WellKnownData.Master_LimiterRedux

• ARDOUR.WellKnownData.Comp_Meter

• ARDOUR.WellKnownData.Comp_Redux

• ARDOUR.WellKnownData.Gate_Meter

• ARDOUR.WellKnownData.Gate_Redux

• ARDOUR.WellKnownData.DeEss_Meter

• ARDOUR.WellKnownData.DeEss_EssRedux

• ARDOUR.WellKnownData.DeEss_HiRedux

• ARDOUR.WellKnownData.Denoise_Meter

• ARDOUR.WellKnownData.Denoise_ReduxLo

• ARDOUR.WellKnownData.Denoise_ReduxHi

∈ ARDOUR.SampleFormat

{#ARDOUR.SampleFormat .cls .enum}

• ARDOUR.SampleFormat.Float

• ARDOUR.SampleFormat.Int24

• ARDOUR.SampleFormat.Int16

∈ ARDOUR.HeaderFormat

{#ARDOUR.HeaderFormat .cls .enum}

• ARDOUR.HeaderFormat.BWF

• ARDOUR.HeaderFormat.WAVE

• ARDOUR.HeaderFormat.WAVE64

• ARDOUR.HeaderFormat.CAF

• ARDOUR.HeaderFormat.AIFF

• ARDOUR.HeaderFormat.iXML

• ARDOUR.HeaderFormat.RF64

• ARDOUR.HeaderFormat.RF64_WAV

• ARDOUR.HeaderFormat.MBWF

• ARDOUR.HeaderFormat.FLAC

∈ ARDOUR.InsertMergePolicy

{#ARDOUR.InsertMergePolicy .cls .enum}

• ARDOUR.InsertMergePolicy.Reject

• ARDOUR.InsertMergePolicy.Relax

• ARDOUR.InsertMergePolicy.Replace

• ARDOUR.InsertMergePolicy.TruncateExisting

• ARDOUR.InsertMergePolicy.TruncateAddition

• ARDOUR.InsertMergePolicy.Extend

∈ ARDOUR.AFLPosition

{#ARDOUR.AFLPosition .cls .enum}

• ARDOUR.AFLPosition.AFLFromBeforeProcessors

• ARDOUR.AFLPosition.AFLFromAfterProcessors

∈ ARDOUR.PFLPosition

{#ARDOUR.PFLPosition .cls .enum}

• ARDOUR.PFLPosition.PFLFromBeforeProcessors

• ARDOUR.PFLPosition.PFLFromAfterProcessors

∈ ARDOUR.AutoReturnTarget

{#ARDOUR.AutoReturnTarget .cls .enum}

• ARDOUR.AutoReturnTarget.LastLocate

• ARDOUR.AutoReturnTarget.RangeSelectionStart

• ARDOUR.AutoReturnTarget.Loop

• ARDOUR.AutoReturnTarget.RegionSelectionStart

∈ ARDOUR.FadeShape

{#ARDOUR.FadeShape .cls .enum}

• ARDOUR.FadeShape.FadeLinear

• ARDOUR.FadeShape.FadeFast

• ARDOUR.FadeShape.FadeSlow

• ARDOUR.FadeShape.FadeConstantPower

• ARDOUR.FadeShape.FadeSymmetric

∈ ARDOUR.MarkerLocatePriority

{#ARDOUR.MarkerLocatePriority .cls .enum}

• ARDOUR.MarkerLocatePriority.FirstMarker

• ARDOUR.MarkerLocatePriority.LastMarker

• ARDOUR.MarkerLocatePriority.NextMarker

∈ ARDOUR.LoopFadeChoice

{#ARDOUR.LoopFadeChoice .cls .enum}

• ARDOUR.LoopFadeChoice.NoLoopFade

• ARDOUR.LoopFadeChoice.EndLoopFade

• ARDOUR.LoopFadeChoice.BothLoopFade

• ARDOUR.LoopFadeChoice.XFadeLoop

∈ ARDOUR.DenormalModel

{#ARDOUR.DenormalModel .cls .enum}

• ARDOUR.DenormalModel.DenormalNone

• ARDOUR.DenormalModel.DenormalFTZ

• ARDOUR.DenormalModel.DenormalDAZ

• ARDOUR.DenormalModel.DenormalFTZDAZ

∈ ARDOUR.BufferingPreset

{#ARDOUR.BufferingPreset .cls .enum}

• ARDOUR.BufferingPreset.Small

• ARDOUR.BufferingPreset.Medium

• ARDOUR.BufferingPreset.Large

• ARDOUR.BufferingPreset.Custom

∈ ARDOUR.EditMode

{#ARDOUR.EditMode .cls .enum}

• ARDOUR.EditMode.Slide

• ARDOUR.EditMode.Ripple

• ARDOUR.EditMode.Lock

∈ ARDOUR.RippleMode

{#ARDOUR.RippleMode .cls .enum}

• ARDOUR.RippleMode.RippleSelected

• ARDOUR.RippleMode.RippleAll

• ARDOUR.RippleMode.RippleInterview

∈ ARDOUR.AutoConnectOption

{#ARDOUR.AutoConnectOption .cls .enum}

• ARDOUR.AutoConnectOption.ManualConnect

• ARDOUR.AutoConnectOption.AutoConnectPhysical

• ARDOUR.AutoConnectOption.AutoConnectMaster

∈ ARDOUR.LayerModel

{#ARDOUR.LayerModel .cls .enum}

• ARDOUR.LayerModel.LaterHigher

• ARDOUR.LayerModel.Manual

∈ ARDOUR.ListenPosition

{#ARDOUR.ListenPosition .cls .enum}

• ARDOUR.ListenPosition.AfterFaderListen

• ARDOUR.ListenPosition.PreFaderListen

∈ ARDOUR.MonitorModel

{#ARDOUR.MonitorModel .cls .enum}

• ARDOUR.MonitorModel.HardwareMonitoring

• ARDOUR.MonitorModel.SoftwareMonitoring

• ARDOUR.MonitorModel.ExternalMonitoring

∈ ARDOUR.SnapTarget

{#ARDOUR.SnapTarget .cls .enum}

• ARDOUR.SnapTarget.SnapTargetGrid

• ARDOUR.SnapTarget.SnapTargetOther

• ARDOUR.SnapTarget.SnapTargetBoth

∈ ARDOUR.RegionSelectionAfterSplit

{#ARDOUR.RegionSelectionAfterSplit .cls .enum}

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.None

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.NewlyCreatedLeft

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.NewlyCreatedRight

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.NewlyCreatedBoth

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.Existing

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.ExistingNewlyCreatedLeft

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.ExistingNewlyCreatedRight

• ARDOUR.SnapTarget.RegionSelectionAfterSplit.ExistingNewlyCreatedBoth

∈ ARDOUR.RangeSelectionAfterSplit

{#ARDOUR.RangeSelectionAfterSplit .cls .enum}

• ARDOUR.SnapTarget.RangeSelectionAfterSplit.ClearSel

• ARDOUR.SnapTarget.RangeSelectionAfterSplit.PreserveSel

• ARDOUR.SnapTarget.RangeSelectionAfterSplit.ForceSel

∈ ARDOUR.TimeSelectionAfterSectionPaste

{#ARDOUR.TimeSelectionAfterSectionPaste .cls .enum}

• ARDOUR.SnapTarget.TimeSelectionAfterSectionPaste.SectionSelectNoop

• ARDOUR.SnapTarget.TimeSelectionAfterSectionPaste.SectionSelectClear

• ARDOUR.SnapTarget.TimeSelectionAfterSectionPaste.SectionSelectRetain

• ARDOUR.SnapTarget.TimeSelectionAfterSectionPaste.SectionSelectRetainAndMovePlayhead

∈ ARDOUR.ScreenSaverMode

{#ARDOUR.ScreenSaverMode .cls .enum}

• ARDOUR.SnapTarget.ScreenSaverMode.InhibitNever

• ARDOUR.SnapTarget.ScreenSaverMode.InhibitWhileRecording

• ARDOUR.SnapTarget.ScreenSaverMode.InhibitAlways

∈ ARDOUR.AppleNSGLViewMode

{#ARDOUR.AppleNSGLViewMode .cls .enum}

• ARDOUR.SnapTarget.AppleNSGLViewMode.NSGLHiRes

• ARDOUR.SnapTarget.AppleNSGLViewMode.NSGLLoRes

• ARDOUR.SnapTarget.AppleNSGLViewMode.NSGLDisable

∈ ARDOUR.PluginGUIBehavior

{#ARDOUR.PluginGUIBehavior .cls .enum}

• ARDOUR.SnapTarget.PluginGUIBehavior.PluginGUIHide

• ARDOUR.SnapTarget.PluginGUIBehavior.PluginGUIDestroyAny

• ARDOUR.SnapTarget.PluginGUIBehavior.PluginGUIDestroyVST

∈ ARDOUR.ClockDeltaMode

{#ARDOUR.ClockDeltaMode .cls .enum}

• ARDOUR.SnapTarget.ClockDeltaMode.NoDelta

• ARDOUR.SnapTarget.ClockDeltaMode.DeltaEditPoint

• ARDOUR.SnapTarget.ClockDeltaMode.DeltaOriginMarker

∈ ARDOUR.WaveformScale

{#ARDOUR.WaveformScale .cls .enum}

• ARDOUR.SnapTarget.WaveformScale.Linear

• ARDOUR.SnapTarget.WaveformScale.Logarithmic

∈ ARDOUR.WaveformShape

{#ARDOUR.WaveformShape .cls .enum}

• ARDOUR.SnapTarget.WaveformShape.Traditional

• ARDOUR.SnapTarget.WaveformShape.Rectified

∈ ARDOUR.MeterLineUp

{#ARDOUR.MeterLineUp .cls .enum}

• ARDOUR.SnapTarget.MeterLineUp.MeteringLineUp24

• ARDOUR.SnapTarget.MeterLineUp.MeteringLineUp20

• ARDOUR.SnapTarget.MeterLineUp.MeteringLineUp18

• ARDOUR.SnapTarget.MeterLineUp.MeteringLineUp15

• ARDOUR.SnapTarget.InputMeterLayout.MeteringLineUp15

∈ ARDOUR.InputMeterLayout

{#ARDOUR.InputMeterLayout .cls .enum}

• ARDOUR.SnapTarget.InputMeterLayout.LayoutVertical

• ARDOUR.SnapTarget.InputMeterLayout.LayoutHorizontal

• ARDOUR.SnapTarget.InputMeterLayout.LayoutAutomatic

∈ ARDOUR.VUMeterStandard

{#ARDOUR.VUMeterStandard .cls .enum}

• ARDOUR.SnapTarget.VUMeterStandard.MeteringVUfrench

• ARDOUR.SnapTarget.VUMeterStandard.MeteringVUamerican

• ARDOUR.SnapTarget.VUMeterStandard.MeteringVUstandard

• ARDOUR.SnapTarget.VUMeterStandard.MeteringVUeight

∈ ARDOUR.ShuttleUnits

{#ARDOUR.ShuttleUnits .cls .enum}

• ARDOUR.SnapTarget.ShuttleUnits.Percentage

• ARDOUR.SnapTarget.ShuttleUnits.Semitones

∈ ARDOUR.SyncSource

{#ARDOUR.SyncSource .cls .enum}

• ARDOUR.SnapTarget.SyncSource.Engine

• ARDOUR.SnapTarget.SyncSource.MTC

• ARDOUR.SnapTarget.SyncSource.MIDIClock

• ARDOUR.SnapTarget.SyncSource.LTC

∈ ARDOUR.TracksAutoNamingRule

{#ARDOUR.TracksAutoNamingRule .cls .enum}

• ARDOUR.SnapTarget.TracksAutoNamingRule.UseDefaultNames

• ARDOUR.SnapTarget.TracksAutoNamingRule.NameAfterDriver

∈ ARDOUR.VST3KnobMode

{#ARDOUR.VST3KnobMode .cls .enum}

• ARDOUR.SnapTarget.VST3KnobMode.VST3KnobPluginDefault

• ARDOUR.SnapTarget.VST3KnobMode.VST3KnobCircularMode

• ARDOUR.SnapTarget.VST3KnobMode.VST3KnobRelativCircularMode

• ARDOUR.SnapTarget.VST3KnobMode.VST3KnobLinearMode

∈ ARDOUR.RecordState

{#ARDOUR.RecordState .cls .enum}

• ARDOUR.Session.RecordState.Disabled

• ARDOUR.Session.RecordState.Enabled

• ARDOUR.Session.RecordState.Recording

∈ ARDOUR.Location.Flags

{#ARDOUR.Location.Flags .cls .enum}

• ARDOUR.LocationFlags.IsMark

• ARDOUR.LocationFlags.IsAutoPunch

• ARDOUR.LocationFlags.IsAutoLoop

• ARDOUR.LocationFlags.IsHidden

• ARDOUR.LocationFlags.IsCDMarker

• ARDOUR.LocationFlags.IsRangeMarker

• ARDOUR.LocationFlags.IsSessionRange

• ARDOUR.LocationFlags.IsSkip

• ARDOUR.LocationFlags.IsSkipping

• ARDOUR.LocationFlags.IsClockOrigin

• ARDOUR.LocationFlags.IsXrun

• ARDOUR.LocationFlags.IsCueMarker

• ARDOUR.LocationFlags.IsSection

• ARDOUR.LocationFlags.IsScene

∈ Glib.FileTest

{#Glib.FileTest .cls .enum}

• ARDOUR.LuaAPI.FileTest.IsRegular

• ARDOUR.LuaAPI.FileTest.IsSymlink

• ARDOUR.LuaAPI.FileTest.IsDir

• ARDOUR.LuaAPI.FileTest.IsExecutable

• ARDOUR.LuaAPI.FileTest.Exists

∈ ARDOUR.DSP.Biquad.Type

{#ARDOUR.DSP.Biquad.Type .cls .enum}

• ARDOUR.DSP.BiquadType.LowPass

• ARDOUR.DSP.BiquadType.HighPass

• ARDOUR.DSP.BiquadType.BandPassSkirt

• ARDOUR.DSP.BiquadType.BandPass0dB

• ARDOUR.DSP.BiquadType.Notch

• ARDOUR.DSP.BiquadType.AllPass

• ARDOUR.DSP.BiquadType.Peaking

• ARDOUR.DSP.BiquadType.LowShelf

• ARDOUR.DSP.BiquadType.HighShelf

• ARDOUR.DSP.BiquadType.MatchedLowPass

• ARDOUR.DSP.BiquadType.MatchedHighPass

• ARDOUR.DSP.BiquadType.MatchedBandPass0dB

• ARDOUR.DSP.BiquadType.MatchedPeaking

∈ ARDOUR.DSP.Generator.Type

{#ARDOUR.DSP.Generator.Type .cls .enum}

• ARDOUR.DSP.NoiseType.UniformWhiteNoise

• ARDOUR.DSP.NoiseType.GaussianWhiteNoise

• ARDOUR.DSP.NoiseType.PinkNoise

∈ ARDOUR.DSP.LTC_TV_STANDARD

{#ARDOUR.DSP.LTC_TV_STANDARD .cls .enum}

• ARDOUR.DSP.LTC_TV_STANDARD.LTC_TV_525_60

• ARDOUR.DSP.LTC_TV_STANDARD.LTC_TV_625_50

• ARDOUR.DSP.LTC_TV_STANDARD.LTC_TV_1125_60

• ARDOUR.DSP.LTC_TV_STANDARD.LTC_TV_FILM_24

∈ ARDOUR.DSP.Convolver.IRChannelConfig

{#ARDOUR.DSP.Convolver.IRChannelConfig .cls .enum}

• ARDOUR.DSP.IRChannelConfig.Mono

• ARDOUR.DSP.IRChannelConfig.MonoToStereo

• ARDOUR.DSP.IRChannelConfig.Stereo

∈ Cairo.LineCap

{#Cairo.LineCap .cls .enum}

• Cairo.LineCap.Butt

• Cairo.LineCap.Round

• Cairo.LineCap.Square

∈ Cairo.LineJoin

{#Cairo.LineJoin .cls .enum}

• Cairo.LineJoin.Miter

• Cairo.LineJoin.Round

• Cairo.LineJoin.Bevel

∈ Cairo.Operator

{#Cairo.Operator .cls .enum}

• Cairo.Operator.Clear

• Cairo.Operator.Source

• Cairo.Operator.Over

• Cairo.Operator.Add

∈ Cairo.Format

{#Cairo.Format .cls .enum}

• Cairo.Format.ARGB32

• Cairo.Format.RGB24

∈ Pango.EllipsizeMode

{#Pango.EllipsizeMode .cls .enum}

• Cairo.EllipsizeMode.None

• Cairo.EllipsizeMode.Start

• Cairo.EllipsizeMode.Middle

• Cairo.EllipsizeMode.End

∈ Pango.Alignment

{#Pango.Alignment .cls .enum}

• Cairo.Alignment.Left

• Cairo.Alignment.Center

• Cairo.Alignment.Right

∈ Pango.WrapMode

{#Pango.WrapMode .cls .enum}

• Cairo.WrapMode.Word

• Cairo.WrapMode.Char

• Cairo.WrapMode.WordChar

∈ LuaDialog.Message.MessageType

{#LuaDialog.Message.MessageType .cls .enum}

• LuaDialog.MessageType.Info

• LuaDialog.MessageType.Warning

• LuaDialog.MessageType.Question

• LuaDialog.MessageType.Error

∈ LuaDialog.Message.ButtonType

{#LuaDialog.Message.ButtonType .cls .enum}

• LuaDialog.ButtonType.OK

• LuaDialog.ButtonType.Close

• LuaDialog.ButtonType.Cancel

• LuaDialog.ButtonType.Yes_No

• LuaDialog.ButtonType.OK_Cancel

∈ LuaDialog.Response

{#LuaDialog.Response .cls .enum}

• LuaDialog.Response.OK

• LuaDialog.Response.Cancel

• LuaDialog.Response.Close

• LuaDialog.Response.Yes

• LuaDialog.Response.No

• LuaDialog.Response.None

∈ Keyboard

• Keyboard.PrimaryModifier

• Keyboard.SecondaryModifier

• Keyboard.TertiaryModifier

• Keyboard.Level4Modifier

• Keyboard.CapsLockModifier

∈ RouteDialogs.InsertAt

{#RouteDialogs.InsertAt .cls .enum}

• ArdourUI.InsertAt.BeforeSelection

• ArdourUI.InsertAt.AfterSelection

• ArdourUI.InsertAt.First

• ArdourUI.InsertAt.Last

∈ ArdourMarker.Type

{#ArdourMarker.Type .cls .enum}

• ArdourUI.MarkerType.Mark

• ArdourUI.MarkerType.Tempo

• ArdourUI.MarkerType.Meter

• ArdourUI.MarkerType.SessionStart

• ArdourUI.MarkerType.SessionEnd

• ArdourUI.MarkerType.RangeStart

• ArdourUI.MarkerType.RangeEnd

• ArdourUI.MarkerType.LoopStart

• ArdourUI.MarkerType.LoopEnd

• ArdourUI.MarkerType.PunchIn

• ArdourUI.MarkerType.PunchOut

∈ ARDOUR.SelectionOperation

{#ARDOUR.SelectionOperation .cls .enum}

• ArdourUI.SelectionOp.Toggle

• ArdourUI.SelectionOp.Set

• ArdourUI.SelectionOp.Extend

• ArdourUI.SelectionOp.Add

∈ TimeAxisView.TrackHeightMode

{#TimeAxisView.TrackHeightMode .cls .enum}

• ArdourUI.TrackHeightMode.OnlySelf

• ArdourUI.TrackHeightMode.TotalHeight

• ArdourUI.TrackHeightMode.HeightPerLane,

∈ Gtk.WindowPosition

{#Gtk.WindowPosition .cls .enum}

• ArdourUI.Gtk.WindowPosition.None

• ArdourUI.Gtk.WindowPosition.Center

• ArdourUI.Gtk.WindowPosition.Mouse

• ArdourUI.Gtk.WindowPosition.CenterAlways

• ArdourUI.Gtk.WindowPosition.CenterOnParent

∈ Editing.GridType

{#Editing.GridType .cls .enum}

• Editing.GridTypeNone

• Editing.GridTypeBar

• Editing.GridTypeBeat

• Editing.GridTypeBeatDiv2

• Editing.GridTypeBeatDiv4

• Editing.GridTypeBeatDiv8

• Editing.GridTypeBeatDiv16

• Editing.GridTypeBeatDiv32

• Editing.GridTypeBeatDiv3

• Editing.GridTypeBeatDiv6

• Editing.GridTypeBeatDiv12

• Editing.GridTypeBeatDiv24

• Editing.GridTypeBeatDiv5

• Editing.GridTypeBeatDiv10

• Editing.GridTypeBeatDiv20

• Editing.GridTypeBeatDiv7

• Editing.GridTypeBeatDiv14

• Editing.GridTypeBeatDiv28

• Editing.GridTypeTimecode

• Editing.GridTypeMinSec

• Editing.GridTypeCDFrame

∈ Editing.SnapMode

{#Editing.SnapMode .cls .enum}

• Editing.SnapOff

• Editing.SnapNormal

• Editing.SnapMagnetic

∈ Editing.MouseMode

{#Editing.MouseMode .cls .enum}

• Editing.MouseObject

• Editing.MouseRange

• Editing.MouseCut

• Editing.MouseTimeFX

• Editing.MouseGrid

• Editing.MouseDraw

• Editing.MouseContent

∈ Editing.ZoomFocus

{#Editing.ZoomFocus .cls .enum}

• Editing.ZoomFocusLeft

• Editing.ZoomFocusRight

• Editing.ZoomFocusCenter

• Editing.ZoomFocusPlayhead

• Editing.ZoomFocusMouse

• Editing.ZoomFocusEdit

∈ Editing.DisplayControl

{#Editing.DisplayControl .cls .enum}

• Editing.FollowPlayhead

• Editing.ShowMeasures

• Editing.ShowWaveforms

• Editing.ShowWaveformsRecording

∈ Editing.ImportMode

{#Editing.ImportMode .cls .enum}

• Editing.ImportAsRegion

• Editing.ImportToTrack

• Editing.ImportAsTrack

• Editing.ImportAsTrigger

∈ Editing.ImportPosition

{#Editing.ImportPosition .cls .enum}

• Editing.ImportAtTimestamp

• Editing.ImportAtEditPoint

• Editing.ImportAtPlayhead

• Editing.ImportAtStart

∈ Editing.ImportDisposition

{#Editing.ImportDisposition .cls .enum}

• Editing.ImportDistinctFiles

• Editing.ImportMergeFiles

• Editing.ImportSerializeFiles

• Editing.ImportDistinctChannels

∈ Editing.NoteNameDisplay

{#Editing.NoteNameDisplay .cls .enum}

• Editing.Always

• Editing.WithMIDNAM

• Editing.Never

∈ Editing.RegionEditDisposition

{#Editing.RegionEditDisposition .cls .enum}

• Editing.BottomPaneOnly

• Editing.OpenBottomPane

• Editing.PreferBottomPane

• Editing.NeverBottomPane

∈ LuaSignal.LuaSignal

{#LuaSignal.LuaSignal .cls .enum}

• LuaSignal.ConfigChanged

• LuaSignal.EngineRunning

• LuaSignal.EngineStopped

• LuaSignal.EngineHalted

• LuaSignal.EngineDeviceListChanged

• LuaSignal.BufferSizeChanged

• LuaSignal.SampleRateChanged

• LuaSignal.FeedbackDetected

• LuaSignal.SuccessfulGraphSort

• LuaSignal.StartTimeChanged

• LuaSignal.EndTimeChanged

• LuaSignal.Exported

• LuaSignal.Change

• LuaSignal.SessionConfigChanged

• LuaSignal.TransportStateChange

• LuaSignal.DirtyChanged

• LuaSignal.StateSaved

• LuaSignal.Xrun

• LuaSignal.TransportLooped

• LuaSignal.SoloActive

• LuaSignal.SoloChanged

• LuaSignal.IsolatedChanged

• LuaSignal.MonitorChanged

• LuaSignal.RecordStateChanged

• LuaSignal.RecordArmStateChanged

• LuaSignal.AudioLoopLocationChanged

• LuaSignal.AudioPunchLocationChanged

• LuaSignal.LocationsModified

• LuaSignal.AuditionActive

• LuaSignal.BundleAddedOrRemoved

• LuaSignal.PositionChanged

• LuaSignal.Located

• LuaSignal.RoutesReconnected

• LuaSignal.RouteAdded

• LuaSignal.RouteGroupPropertyChanged

• LuaSignal.RouteAddedToRouteGroup

• LuaSignal.RouteRemovedFromRouteGroup

• LuaSignal.StepEditStatusChange

• LuaSignal.RouteGroupAdded

• LuaSignal.RouteGroupRemoved

• LuaSignal.RouteGroupsReordered

• LuaSignal.PluginListChanged

• LuaSignal.PluginStatusChanged

• LuaSignal.DiskOverrun

• LuaSignal.DiskUnderrun

• LuaSignal.RegionsPropertyChanged

• LuaSignal.LuaTimerS

• LuaSignal.LuaTimerDS

• LuaSignal.SetSession

• LuaSignal.SelectionChanged

Class Index

• ARDOUR

• ARDOUR:Amp

• ARDOUR:AnyTime

• ARDOUR:AsyncMIDIPort

• ARDOUR:AudioBackend

• ARDOUR:AudioBackendInfo

• ARDOUR:AudioBuffer

• ARDOUR:AudioEngine

• ARDOUR:AudioPlaylist

• ARDOUR:AudioPort

• ARDOUR:AudioPortMeters

• ARDOUR:AudioRegion

• ARDOUR:AudioRom

• ARDOUR:AudioSource

• ARDOUR:AudioTrack

• ARDOUR:AudioTrackList

• ARDOUR:Automatable

• ARDOUR:AutomatableSequence

• ARDOUR:AutomationControl

• ARDOUR:AutomationList

• ARDOUR:AutomationTypeSet

• ARDOUR:BackendVector

• ARDOUR:BufferSet

• ARDOUR:Bundle

• ARDOUR:BundleListPtr

• ARDOUR:ChanCount

• ARDOUR:ChanMapping

• ARDOUR:ConstBundleListPtr

• ARDOUR:ConstRouteListPtr

• ARDOUR:ControlList

• ARDOUR:ControlListPtr

• ARDOUR:ControlProtocolInfo

• ARDOUR:ControlProtocolInfoList

• ARDOUR:ControlProtocolManager

• ARDOUR:ControllableSet

• ARDOUR.DSP

• ARDOUR:DSP:Biquad

• ARDOUR:DSP:Convolution

• ARDOUR:DSP:Convolver

• ARDOUR:DSP:DspShm

• ARDOUR:DSP:FFTSpectrum

• ARDOUR:DSP:Generator

• ARDOUR:DSP:IRSettings

• ARDOUR:DSP:LTCReader

• ARDOUR:DSP:LowPass

• ARDOUR:DSP:StereoCorrelation

• ARDOUR:DataType

• ARDOUR:DelayLine

• ARDOUR:Delivery

• ARDOUR:DeviceStatus

• ARDOUR:DeviceStatusVector

• ARDOUR:DiskIOProcessor

• ARDOUR:DiskReader

• ARDOUR:DiskWriter

• ARDOUR:EventList

• ARDOUR:EventPtrList

• ARDOUR:FileSource

• ARDOUR:FluidSynth

• ARDOUR:GainControl

• ARDOUR:IDMap

• ARDOUR:IDNameMap

• ARDOUR:IO

• ARDOUR:IOProcessor

• ARDOUR:InterThreadInfo

• ARDOUR:InternalReturn

• ARDOUR:InternalSend

• ARDOUR:LatencyRange

• ARDOUR:Latent

• ARDOUR:Location

• ARDOUR:LocationList

• ARDOUR:Locations

• ARDOUR.LuaAPI

• ARDOUR:LuaAPI:Rubberband

• ARDOUR:LuaAPI:Vamp

• ARDOUR:LuaOSC:Address

• ARDOUR:LuaProc

• ARDOUR:LuaTableRef

• ARDOUR:MIDIPortMeters

• ARDOUR:MPGainControl

• ARDOUR:MPToggleControl

• ARDOUR:MidiBuffer

• ARDOUR:MidiModel

• ARDOUR:MidiModel:DiffCommand

• ARDOUR:MidiModel:NoteDiffCommand

• ARDOUR:MidiPlaylist

• ARDOUR:MidiPort

• ARDOUR:MidiRegion

• ARDOUR:MidiSource

• ARDOUR:MidiTrack

• ARDOUR:MidiTrackList

• ARDOUR:MixerScene

• ARDOUR:MonitorControl

• ARDOUR:MonitorProcessor

• ARDOUR:MuteControl

• ARDOUR:NotePtrList

• ARDOUR:OwnedPropertyList

• ARDOUR:PDC

• ARDOUR:PIControl

• ARDOUR:PannerShell

• ARDOUR:ParameterDescriptor

• ARDOUR:ParameterList

• ARDOUR:PatchChangePtrList

• ARDOUR:PeakMeter

• ARDOUR:PhaseControl

• ARDOUR:Playlist

• ARDOUR:PlaylistList

• ARDOUR:Plugin

• ARDOUR:Plugin:IOPortDescription

• ARDOUR:PluginControl

• ARDOUR:PluginInfo

• ARDOUR:PluginInfoList

• ARDOUR:PluginInsert

• ARDOUR:PluginPropertyControl

• ARDOUR.PluginType

• ARDOUR:PolarityProcessor

• ARDOUR:Port

• ARDOUR:PortEngine

• ARDOUR:PortList

• ARDOUR:PortManager

• ARDOUR:PortSet

• ARDOUR:PresentationInfo

• ARDOUR:PresetRecord

• ARDOUR:PresetVector

• ARDOUR:Processor

• ARDOUR:ProcessorList

• ARDOUR:ProcessorVector

• ARDOUR:Properties:BoolProperty

• ARDOUR:Properties:FloatProperty

• ARDOUR:Properties:SamplePosProperty

• ARDOUR:Properties:StringProperty

• ARDOUR:Properties:TimeCntProperty

• ARDOUR:Properties:TimePosProperty

• ARDOUR:PropertyChange

• ARDOUR:PropertyList

• ARDOUR:RCConfiguration

• ARDOUR:RawMidiParser

• ARDOUR:ReadOnlyControl

• ARDOUR:Readable

• ARDOUR:ReadableList

• ARDOUR:Region

• ARDOUR:RegionFactory

• ARDOUR:RegionFxPlugin

• ARDOUR:RegionList

• ARDOUR:RegionListPtr

• ARDOUR:RegionMap

• ARDOUR:RegionVector

• ARDOUR:Return

• ARDOUR:Route

• ARDOUR:Route:ProcessorStreams

• ARDOUR:RouteGroup

• ARDOUR:RouteGroupList

• ARDOUR:RouteList

• ARDOUR:RouteListPtr

• ARDOUR:RouteStateMap

• ARDOUR:Send

• ARDOUR:Session

• ARDOUR:SessionConfiguration

• ARDOUR:SessionObject

• ARDOUR:SessionObjectPtr

• ARDOUR:SessionPlaylists

• ARDOUR:SideChain

• ARDOUR:SimpleExport

• ARDOUR:Slavable

• ARDOUR:SlavableAutomationControl

• ARDOUR:SoloControl

• ARDOUR:SoloIsolateControl

• ARDOUR:SoloSafeControl

• ARDOUR:Source

• ARDOUR:SourceList

• ARDOUR:Stripable

• ARDOUR:StripableList

• ARDOUR:SurroundPannable

• ARDOUR:SurroundReturn

• ARDOUR:SurroundSend

• ARDOUR:TimelineRange

• ARDOUR:TimelineRangeList

• ARDOUR:Track

• ARDOUR:UnknownProcessor

• ARDOUR:UserBundle

• ARDOUR:VCA

• ARDOUR:VCAList

• ARDOUR:VCAManager

• ARDOUR:VCAVector

• ARDOUR:WeakAudioSourceList

• ARDOUR:WeakRouteList

• ARDOUR:WeakSourceList

• ARDOUR:XrunPositions

• ArdourUI

• ArdourUI:ARDOUR::AutomationListList

• ArdourUI:ArdourMarker

• ArdourUI:ArdourMarkerList

• ArdourUI:AutomationSelection

• ArdourUI:AxisView

• ArdourUI:ControlPoint

• ArdourUI:ControlPointList

• ArdourUI:EditingContext

• ArdourUI:Editor

• ArdourUI:MarkerSelection

• ArdourUI:MidiTimeAxisView

• ArdourUI:PointSelection

• ArdourUI:RegionSelection

• ArdourUI:RegionView

• ArdourUI:RouteTimeAxisView

• ArdourUI:RouteUI

• ArdourUI:Selectable

• ArdourUI:Selection

• ArdourUI:SelectionList

• ArdourUI:StripableTimeAxisView

• ArdourUI:TimeAxisView

• ArdourUI:TimeAxisViewItem

• ArdourUI:TimeSelection

• ArdourUI:TrackSelection

• ArdourUI:TrackViewList

• ArdourUI:TrackViewStdList

• ArdourUI:UIConfiguration

• C:ByteArray

• C:ByteVector

• C:DoubleArray

• C:DoubleVector

• C:FloatArray

• C:FloatArrayVector

• C:FloatVector

• C:Int64List

• C:IntArray

• C:IntVector

• C:StringList

• C:StringVector

• Cairo:Context

• Cairo:ImageSurface

• Cairo:PangoLayout

• Evoral:Control

• Evoral:ControlEvent

• Evoral:ControlList

• Evoral:ControlSet

• Evoral:Event

• Evoral:EventPtr

• Evoral:NotePtr

• Evoral:Parameter

• Evoral:ParameterDescriptor

• Evoral:PatchChangePtr

• Evoral:Range

• Evoral:Sequence

• Keyboard

• LuaDialog:Dialog

• LuaDialog:Message

• LuaDialog:ProgressWindow

• LuaSignal:Set

• PBD

• PBD:Command

• PBD:Configuration

• PBD:Controllable

• PBD:HistoryOwner

• PBD:ID

• PBD:IdVector

• PBD:Progress

• PBD:RingBuffer8

• PBD:RingBufferF

• PBD:RingBufferI

• PBD:Stateful

• PBD:StatefulDestructible

• PBD:StatefulDestructiblePtr

• PBD:StatefulDiffCommand

• PBD:StatefulPtr

• PBD:XMLNode

• Temporal

• Temporal:BBT_Argument

• Temporal:BBT_Offset

• Temporal:BBT_TIME

• Temporal:Beats

• Temporal:Meter

• Temporal:MeterPoint

• Temporal:Point

• Temporal:Tempo

• Temporal:TempoMap

• Temporal:TempoMapPoint

• Temporal:TempoMapPoints

• Temporal:TempoMetric

• Temporal:TempoPoint

• Temporal:ratio

• Temporal:timecnt_t

• Temporal:timepos_t

• Timecode:Time

• Vamp:Plugin

• Vamp:Plugin:Feature

• Vamp:Plugin:FeatureList

• Vamp:Plugin:FeatureSet

• Vamp:Plugin:OutputDescriptor

• Vamp:Plugin:OutputList

• Vamp:PluginBase

• Vamp:PluginBase:ParameterDescriptor

• Vamp:PluginBase:ParameterList

• Vamp:RealTime

• os

Ardour 9.3  -  Wed, 13 May 2026 02:00:55 +0000