#include <alsa_audiobackend.h>

Inheritance diagram for ARDOUR::AlsaAudioBackend:

Classes
struct	AlsaMidiDeviceInfo

class	AudioSlave

struct	ThreadData

Public Member Functions
	AlsaAudioBackend (AudioEngine &e, AudioBackendInfo &info)

	~AlsaAudioBackend ()

std::string	name () const

bool	is_realtime () const

bool	use_separate_input_and_output_devices () const

bool	match_input_output_devices_or_none () const

bool	can_set_period_size () const

std::vector< DeviceStatus >	enumerate_devices () const

std::vector< DeviceStatus >	enumerate_input_devices () const

std::vector< DeviceStatus >	enumerate_output_devices () const

std::vector< float >	available_sample_rates (const std::string &device) const

std::vector< float >	available_sample_rates2 (const std::string &, const std::string &) const

std::vector< uint32_t >	available_buffer_sizes (const std::string &device) const

std::vector< uint32_t >	available_buffer_sizes2 (const std::string &, const std::string &) const

std::vector< uint32_t >	available_period_sizes (const std::string &driver, const std::string &device) const

bool	can_change_sample_rate_when_running () const

bool	can_change_buffer_size_when_running () const

bool	can_measure_systemic_latency () const

bool	can_change_systemic_latency_when_running () const

bool	can_request_update_devices ()

bool	update_devices ()

int	set_device_name (const std::string &)

int	set_input_device_name (const std::string &)

int	set_output_device_name (const std::string &)

int	set_sample_rate (float)

int	set_buffer_size (uint32_t)

int	set_peridod_size (uint32_t)

int	set_interleaved (bool yn)

int	set_systemic_input_latency (uint32_t)

int	set_systemic_output_latency (uint32_t)

int	set_systemic_midi_input_latency (std::string const, uint32_t)

int	set_systemic_midi_output_latency (std::string const, uint32_t)

int	reset_device ()

std::string	device_name () const

std::string	input_device_name () const

std::string	output_device_name () const

float	sample_rate () const

uint32_t	buffer_size () const

uint32_t	period_size () const

bool	interleaved () const

uint32_t	systemic_input_latency () const

uint32_t	systemic_output_latency () const

uint32_t	systemic_midi_input_latency (std::string const) const

uint32_t	systemic_midi_output_latency (std::string const) const

bool	can_set_systemic_midi_latencies () const

std::string	control_app_name () const

void	launch_control_app ()

std::vector< std::string >	enumerate_midi_options () const

int	set_midi_option (const std::string &)

std::string	midi_option () const

std::vector< DeviceStatus >	enumerate_midi_devices () const

int	set_midi_device_enabled (std::string const, bool)

bool	midi_device_enabled (std::string const) const

int	stop ()

int	freewheel (bool)

float	dsp_load () const

size_t	raw_buffer_size (DataType t)

samplepos_t	sample_time ()

samplepos_t	sample_time_at_cycle_start ()

pframes_t	samples_since_cycle_start ()

int	create_process_thread (std::function< void()> func)

int	join_process_threads ()

bool	in_process_thread ()

uint32_t	process_thread_count ()

void	update_latencies ()

void *	private_handle () const

const std::string &	my_name () const

bool	port_is_physical (PortEngine::PortHandle ph) const

void	get_physical_outputs (DataType type, std::vector< std::string > &results)

void	get_physical_inputs (DataType type, std::vector< std::string > &results)

ChanCount	n_physical_outputs () const

ChanCount	n_physical_inputs () const

uint32_t	port_name_size () const

int	set_port_name (PortEngine::PortHandle ph, const std::string &name)

std::string	get_port_name (PortEngine::PortHandle ph) const

PortFlags	get_port_flags (PortEngine::PortHandle ph) const

PortEngine::PortPtr	get_port_by_name (std::string const &name) const

int	get_port_property (PortEngine::PortHandle ph, const std::string &key, std::string &value, std::string &type) const

int	set_port_property (PortEngine::PortHandle ph, const std::string &key, const std::string &value, const std::string &type)

int	get_ports (const std::string &port_name_pattern, DataType type, PortFlags flags, std::vector< std::string > &results) const

DataType	port_data_type (PortEngine::PortHandle ph) const

PortEngine::PortPtr	register_port (const std::string &shortname, ARDOUR::DataType type, ARDOUR::PortFlags flags)

void	unregister_port (PortHandle ph)

int	connect (const std::string &src, const std::string &dst)

int	disconnect (const std::string &src, const std::string &dst)

int	connect (PortEngine::PortHandle ph, const std::string &other)

int	disconnect (PortEngine::PortHandle ph, const std::string &other)

int	disconnect_all (PortEngine::PortHandle ph)

bool	connected (PortEngine::PortHandle ph, bool process_callback_safe)

bool	connected_to (PortEngine::PortHandle ph, const std::string &other, bool process_callback_safe)

bool	physically_connected (PortEngine::PortHandle ph, bool process_callback_safe)

int	get_connections (PortEngine::PortHandle ph, std::vector< std::string > &results, bool process_callback_safe)

int	midi_event_get (pframes_t &timestamp, size_t &size, uint8_t const *buf, void port_buffer, uint32_t event_index)

int	midi_event_put (void port_buffer, pframes_t timestamp, const uint8_t buffer, size_t size)

uint32_t	get_midi_event_count (void *port_buffer)

void	midi_clear (void *port_buffer)

bool	can_monitor_input () const

int	request_input_monitoring (PortHandle, bool)

int	ensure_input_monitoring (PortHandle, bool)

bool	monitoring_input (PortHandle)

void	set_latency_range (PortHandle, bool for_playback, LatencyRange)

LatencyRange	get_latency_range (PortHandle, bool for_playback)

void *	get_buffer (PortHandle, pframes_t)

void *	main_process_thread ()

Public Member Functions inherited from ARDOUR::AudioBackend
	AudioBackend (AudioEngine &e, AudioBackendInfo &i)

virtual	~AudioBackend ()

AudioBackendInfo &	info () const

virtual bool	is_jack () const

virtual int	client_real_time_priority ()

virtual bool	requires_driver_selection () const

virtual std::vector< std::string >	enumerate_drivers () const

virtual int	set_driver (const std::string &drivername)

virtual bool	can_use_buffered_io ()

virtual void	set_use_buffered_io (bool)

virtual bool	get_use_buffered_io ()

virtual float	default_sample_rate () const

virtual uint32_t	default_buffer_size (const std::string &device) const

virtual int	drop_device ()

virtual std::string	driver_name () const

int	start (bool for_latency_measurement=false)

virtual void	transport_start ()

virtual void	transport_stop ()

virtual TransportState	transport_state () const

virtual void	transport_locate (samplepos_t pos)

virtual samplepos_t	transport_sample () const

virtual int	set_time_master (bool yn)

virtual int	usecs_per_cycle () const

virtual bool	get_sync_offset (pframes_t &offset) const

virtual bool	speed_and_position (double &speed, samplepos_t &position)

Public Member Functions inherited from ARDOUR::PortEngine
	PortEngine (PortManager &pm)

virtual	~PortEngine ()

virtual bool	externally_connected (PortHandle port, bool process_callback_safe=true)

Public Member Functions inherited from ARDOUR::PortEngineSharedImpl
	PortEngineSharedImpl (PortManager &mgr, std::string const &instance_name)

virtual	~PortEngineSharedImpl ()

bool	port_is_physical (PortEngine::PortHandle) const

void	get_physical_outputs (DataType type, std::vector< std::string > &)

void	get_physical_inputs (DataType type, std::vector< std::string > &)

ChanCount	n_physical_outputs () const

ChanCount	n_physical_inputs () const

uint32_t	port_name_size () const

int	set_port_name (PortEngine::PortHandle, const std::string &)

std::string	get_port_name (PortEngine::PortHandle) const

PortFlags	get_port_flags (PortEngine::PortHandle) const

PortEngine::PortPtr	get_port_by_name (const std::string &) const

int	get_port_property (PortEngine::PortHandle, const std::string &key, std::string &value, std::string &type) const

int	set_port_property (PortEngine::PortHandle, const std::string &key, const std::string &value, const std::string &type)

int	get_ports (const std::string &port_name_pattern, DataType type, PortFlags flags, std::vector< std::string > &) const

DataType	port_data_type (PortEngine::PortHandle) const

PortEngine::PortPtr	register_port (const std::string &shortname, ARDOUR::DataType, ARDOUR::PortFlags)

int	connect (const std::string &src, const std::string &dst)

int	disconnect (const std::string &src, const std::string &dst)

int	connect (PortEngine::PortHandle, const std::string &)

int	disconnect (PortEngine::PortHandle, const std::string &)

int	disconnect_all (PortEngine::PortHandle)

bool	connected (PortEngine::PortHandle, bool process_callback_safe)

bool	connected_to (PortEngine::PortHandle, const std::string &, bool process_callback_safe)

bool	physically_connected (PortEngine::PortHandle, bool process_callback_safe)

int	get_connections (PortEngine::PortHandle, std::vector< std::string > &, bool process_callback_safe)

Protected Member Functions
int	_start (bool for_latency_measurement)

Protected Member Functions inherited from ARDOUR::PortEngineSharedImpl
void	port_connect_callback (const std::string &a, const std::string &b, bool conn)

void	process_connection_queue_locked (PortManager &mgr)

void	port_connect_add_remove_callback ()

void	clear_ports ()

BackendPortPtr	add_port (const std::string &shortname, ARDOUR::DataType, ARDOUR::PortFlags)

void	unregister_ports (bool system_only=false)

bool	valid_port (BackendPortHandle port) const

BackendPortPtr	find_port (const std::string &port_name) const

void	list_ports () const

Private Types
typedef std::vector< AudioSlave * >	AudioSlaves

Private Member Functions
struct AlsaMidiDeviceInfo *	midi_device_info (std::string const) const

void	auto_update_midi_devices ()

bool	listen_for_midi_device_changes ()

void	stop_listen_for_midi_device_changes ()

void	midi_device_thread ()

BackendPort *	port_factory (std::string const &name, ARDOUR::DataType dt, ARDOUR::PortFlags flags)

int	register_system_audio_ports ()

int	register_system_midi_ports (const std::string device="")

void	update_system_port_latencies ()

void	update_systemic_audio_latencies ()

void	update_systemic_midi_latencies ()

bool	add_slave (const char *slave_device, unsigned int slave_rate, unsigned int slave_spp, unsigned int slave_ppc, AudioSlave::DuplexMode)

Static Private Member Functions
static void *	_midi_device_thread (void *arg)

static void *	alsa_process_thread (void *)

Private Attributes
std::string	_instance_name

Alsa_pcmi *	_pcmi

bool	_run

bool	_active

bool	_freewheel

bool	_freewheeling

bool	_measure_latency

uint64_t	_last_process_start

std::string	_input_audio_device

std::string	_output_audio_device

std::string	_midi_driver_option

AlsaDeviceReservation	_device_reservation

float	_samplerate

size_t	_samples_per_period

size_t	_periods_per_cycle

uint32_t	_systemic_audio_input_latency

uint32_t	_systemic_audio_output_latency

std::map< std::string, struct AlsaMidiDeviceInfo * >	_midi_devices

pthread_t	_midi_device_thread_id

bool	_midi_device_thread_active

pthread_mutex_t	_device_port_mutex

float	_dsp_load

ARDOUR::DSPLoadCalculator	_dsp_load_calc

samplecnt_t	_processed_samples

pthread_t	_main_thread

double	_t0

double	_t1

std::vector< pthread_t >	_threads

std::vector< AlsaMidiOut * >	_rmidi_out

std::vector< AlsaMidiIn * >	_rmidi_in

AudioSlaves	_slaves

Static Private Attributes
static std::vector< std::string >	_midi_options

static std::vector< AudioBackend::DeviceStatus >	_input_audio_device_status

static std::vector< AudioBackend::DeviceStatus >	_output_audio_device_status

static std::vector< AudioBackend::DeviceStatus >	_duplex_audio_device_status

static std::vector< AudioBackend::DeviceStatus >	_midi_device_status

static ARDOUR::ALSADeviceInfo	_input_audio_device_info

static ARDOUR::ALSADeviceInfo	_output_audio_device_info

static size_t	_max_buffer_size

Additional Inherited Members
Public Types inherited from ARDOUR::AudioBackend
enum	ErrorCode { NoError = 0 , BackendInitializationError = -64 , BackendDeinitializationError , BackendReinitializationError , AudioDeviceOpenError , AudioDeviceCloseError , AudioDeviceInvalidError , AudioDeviceNotAvailableError , AudioDeviceNotConnectedError , AudioDeviceReservationError , AudioDeviceIOError , MidiDeviceOpenError , MidiDeviceCloseError , MidiDeviceNotAvailableError , MidiDeviceNotConnectedError , MidiDeviceIOError , SampleFormatNotSupportedError , SampleRateNotSupportedError , RequestedInputLatencyNotSupportedError , RequestedOutputLatencyNotSupportedError , PeriodSizeNotSupportedError , PeriodCountNotSupportedError , DeviceConfigurationNotSupportedError , ChannelCountNotSupportedError , InputChannelCountNotSupportedError , OutputChannelCountNotSupportedError , AquireRealtimePermissionError , SettingAudioThreadPriorityError , SettingMIDIThreadPriorityError , ProcessThreadStartError , FreewheelThreadStartError , PortRegistrationError , PortReconnectError , OutOfMemoryError }

enum	StandardDeviceName { DeviceNone , DeviceDefault }

enum	TimingTypes { DeviceWait = 0 , RunLoop , NTT }

Public Types inherited from ARDOUR::PortEngine
typedef std::shared_ptr< ProtoPort >	PortPtr

typedef PortPtr const &	PortHandle

Static Public Member Functions inherited from ARDOUR::AudioBackend
static std::string	get_error_string (ErrorCode)

static std::string	get_standard_device_name (StandardDeviceName)

static size_t	thread_stack_size ()

Public Attributes inherited from ARDOUR::AudioBackend
PBD::TimingStats	dsp_stats [NTT]

Protected Types inherited from ARDOUR::PortEngineSharedImpl
typedef std::map< std::string, BackendPortPtr >	PortMap

typedef std::set< BackendPortPtr, SortByPortName >	PortIndex

typedef std::set< BackendPortPtr >	PortRegistry

Protected Attributes inherited from ARDOUR::AudioBackend
AudioBackendInfo &	_info

AudioEngine &	engine

Protected Attributes inherited from ARDOUR::PortEngine
PortManager &	manager

Protected Attributes inherited from ARDOUR::PortEngineSharedImpl
std::string	_instance_name

std::vector< BackendPortPtr >	_system_inputs

std::vector< BackendPortPtr >	_system_outputs

std::vector< BackendPortPtr >	_system_midi_in

std::vector< BackendPortPtr >	_system_midi_out

std::vector< PortConnectData * >	_port_connection_queue

pthread_mutex_t	_port_callback_mutex

std::atomic< int >	_port_change_flag

SerializedRCUManager< PortMap >	_portmap

SerializedRCUManager< PortIndex >	_ports

SerializedRCUManager< PortRegistry >	_portregistry

Detailed Description

Definition at line 119 of file alsa_audiobackend.h.

Member Typedef Documentation

◆ AudioSlaves

typedef std::vector<AudioSlave*> ARDOUR::AlsaAudioBackend::AudioSlaves

private

Definition at line 414 of file alsa_audiobackend.h.

Constructor & Destructor Documentation

◆ AlsaAudioBackend()

ARDOUR::AlsaAudioBackend::AlsaAudioBackend	(	AudioEngine &	e,
		AudioBackendInfo &	info
	)

◆ ~AlsaAudioBackend()

ARDOUR::AlsaAudioBackend::~AlsaAudioBackend ( )

Member Function Documentation

◆ _midi_device_thread()

static void* ARDOUR::AlsaAudioBackend::_midi_device_thread ( void * arg )

staticprivate

◆ _start()

int ARDOUR::AlsaAudioBackend::_start ( bool for_latency_measurement )

protectedvirtual

Implements ARDOUR::AudioBackend.

◆ add_slave()

bool ARDOUR::AlsaAudioBackend::add_slave	(	const char *	slave_device,
		unsigned int	slave_rate,
		unsigned int	slave_spp,
		unsigned int	slave_ppc,
		AudioSlave::DuplexMode
	)

private

◆ alsa_process_thread()

static void* ARDOUR::AlsaAudioBackend::alsa_process_thread ( void * )

staticprivate

◆ auto_update_midi_devices()

void ARDOUR::AlsaAudioBackend::auto_update_midi_devices ( )

private

◆ available_buffer_sizes()

std::vector<uint32_t> ARDOUR::AlsaAudioBackend::available_buffer_sizes ( const std::string & device ) const

virtual

Returns a collection of uint32 identifying buffer sizes that are potentially usable with the hardware identified by device . Any of these values may be supplied in other calls to this backend as the desired buffer size to use with the name device, but the requested buffer size may turn out to be unavailable, or become invalid at any time.

Implements ARDOUR::AudioBackend.

◆ available_buffer_sizes2()

std::vector<uint32_t> ARDOUR::AlsaAudioBackend::available_buffer_sizes2	(	const std::string &	,
		const std::string &
	)		const

virtual

Reimplemented from ARDOUR::AudioBackend.

◆ available_period_sizes()

std::vector<uint32_t> ARDOUR::AlsaAudioBackend::available_period_sizes	(	const std::string &	driver,
		const std::string &	device
	)		const

virtual

Returns a vector of supported period-sizes for the given driver

Reimplemented from ARDOUR::AudioBackend.

◆ available_sample_rates()

std::vector<float> ARDOUR::AlsaAudioBackend::available_sample_rates ( const std::string & device ) const

virtual

Returns a collection of float identifying sample rates that are potentially usable with the hardware identified by device . Any of these values may be supplied in other calls to this backend as the desired sample rate to use with the name device, but the requested sample rate may turn out to be unavailable, or become invalid at any time.

Implements ARDOUR::AudioBackend.

◆ available_sample_rates2()

std::vector<float> ARDOUR::AlsaAudioBackend::available_sample_rates2	(	const std::string &	,
		const std::string &
	)		const

virtual

Reimplemented from ARDOUR::AudioBackend.

◆ buffer_size()

uint32_t ARDOUR::AlsaAudioBackend::buffer_size ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ can_change_buffer_size_when_running()

bool ARDOUR::AlsaAudioBackend::can_change_buffer_size_when_running ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ can_change_sample_rate_when_running()

bool ARDOUR::AlsaAudioBackend::can_change_sample_rate_when_running ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ can_change_systemic_latency_when_running()

bool ARDOUR::AlsaAudioBackend::can_change_systemic_latency_when_running ( ) const

inlinevirtual

return true if the backend can measure and update systemic latencies without restart.

Reimplemented from ARDOUR::AudioBackend.

Definition at line 147 of file alsa_audiobackend.h.

◆ can_measure_systemic_latency()

bool ARDOUR::AlsaAudioBackend::can_measure_systemic_latency ( ) const

virtual

return true if the backend is configured using a single full-duplex device and measuring systemic latency can produce meaningful results.

Implements ARDOUR::AudioBackend.

◆ can_monitor_input()

bool ARDOUR::AlsaAudioBackend::can_monitor_input ( ) const

virtual

Return true if the implementation can offer input monitoring.

Input monitoring involves the (selective) routing of incoming data to an outgoing data stream, without the data being passed to the CPU.

Only certain audio hardware can provide this, and only certain audio APIs can offer it.

Implements ARDOUR::PortEngine.

◆ can_request_update_devices()

bool ARDOUR::AlsaAudioBackend::can_request_update_devices ( )

inlinevirtual

Returns: true if backend supports requesting an update to the device list and any cached properties associated with the devices.

Reimplemented from ARDOUR::AudioBackend.

Definition at line 149 of file alsa_audiobackend.h.

◆ can_set_period_size()

bool ARDOUR::AlsaAudioBackend::can_set_period_size ( ) const

inlinevirtual

An interface to set buffers/period for playback latency. useful for ALSA or JACK/ALSA on Linux.

Returns: true if the backend supports period-size configuration

Reimplemented from ARDOUR::AudioBackend.

Definition at line 132 of file alsa_audiobackend.h.

◆ can_set_systemic_midi_latencies()

bool ARDOUR::AlsaAudioBackend::can_set_systemic_midi_latencies ( ) const

inlinevirtual

if backend supports systemic_midi_[in|ou]tput_latency()

Implements ARDOUR::AudioBackend.

Definition at line 179 of file alsa_audiobackend.h.

◆ connect() [1/2]

int ARDOUR::AlsaAudioBackend::connect	(	const std::string &	src,
		const std::string &	dst
	)

inlinevirtual

Ensure that data written to the port named by src will be readable from the port named by dst

Parameters

src	name of source port to connect
dst	name of destination (sink) port

Returns: zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 238 of file alsa_audiobackend.h.

◆ connect() [2/2]

int ARDOUR::AlsaAudioBackend::connect	(	PortEngine::PortHandle	src,
		const std::string &	dst
	)

inlinevirtual

Ensure that data written to the port referenced by src will be readable from the port named by dst

Parameters

src	PortHandle of source port to connect
dst	PortHandle of destination (sink) port

Returns: zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 240 of file alsa_audiobackend.h.

◆ connected()

bool ARDOUR::AlsaAudioBackend::connected	(	PortEngine::PortHandle	port,
		bool	process_callback_safe
	)

inlinevirtual

Test if given port is connected

Parameters

port	PortHandle of port to test
process_callback_safe	true if this method is not called from rt-context of backend callbacks

Returns: true if the port referred to by port has any connections to other ports. Return false otherwise.

Implements ARDOUR::PortEngine.

Definition at line 243 of file alsa_audiobackend.h.

◆ connected_to()

bool ARDOUR::AlsaAudioBackend::connected_to	(	PortEngine::PortHandle	port,
		const std::string &	name,
		bool	process_callback_safe
	)

inlinevirtual

Test port connection

Parameters

port	PortHandle of source port to test
name	name of destination to test
process_callback_safe	true if this method is not called from rt-context of backend callbacks

Returns: true if the port referred to by port is connected to the port named by name . Return false otherwise.

Implements ARDOUR::PortEngine.

Definition at line 244 of file alsa_audiobackend.h.

◆ control_app_name()

std::string ARDOUR::AlsaAudioBackend::control_app_name ( ) const

inlinevirtual

Return the name of a control application for the selected/in-use device. If no such application exists, or if no device has been selected or is in-use, return an empty string.

Implements ARDOUR::AudioBackend.

Definition at line 182 of file alsa_audiobackend.h.

◆ create_process_thread()

int ARDOUR::AlsaAudioBackend::create_process_thread ( std::function< void()> func )

virtual

Create a new thread suitable for running part of the buffer process cycle (i.e. Realtime scheduling, memory allocation, stacksize, etc. are all correctly setup). The thread will begin executing func, and will exit when that function returns.

Parameters

func	process function to run

Implements ARDOUR::AudioBackend.

◆ device_name()

std::string ARDOUR::AlsaAudioBackend::device_name ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ disconnect() [1/2]

int ARDOUR::AlsaAudioBackend::disconnect	(	const std::string &	src,
		const std::string &	dst
	)

inlinevirtual

Remove any existing connection between the ports named by src and dst

Parameters

src	name of source port to dis-connect to disconnect from
dst	name of destination (sink) port to disconnect

Returns: zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 239 of file alsa_audiobackend.h.

◆ disconnect() [2/2]

int ARDOUR::AlsaAudioBackend::disconnect	(	PortEngine::PortHandle	src,
		const std::string &	dst
	)

inlinevirtual

Remove any existing connection between the port referenced by src and the port named dst

Parameters

src	PortHandle of source port to disconnect from
dst	PortHandle of destination (sink) port to disconnect

Returns: zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 241 of file alsa_audiobackend.h.

◆ disconnect_all()

int ARDOUR::AlsaAudioBackend::disconnect_all ( PortEngine::PortHandle port )

inlinevirtual

Remove all connections between the port referred to by port and any other ports.

Parameters

port	PortHandle of port to disconnect

Returns: zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 242 of file alsa_audiobackend.h.

◆ dsp_load()

float ARDOUR::AlsaAudioBackend::dsp_load ( ) const

virtual

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).

Implements ARDOUR::AudioBackend.

◆ ensure_input_monitoring()

int ARDOUR::AlsaAudioBackend::ensure_input_monitoring	(	PortHandle	,
		bool
	)

virtual

Implements ARDOUR::PortEngine.

◆ enumerate_devices()

std::vector<DeviceStatus> ARDOUR::AlsaAudioBackend::enumerate_devices ( ) const

virtual

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.

Implements ARDOUR::AudioBackend.

◆ enumerate_input_devices()

std::vector<DeviceStatus> ARDOUR::AlsaAudioBackend::enumerate_input_devices ( ) const

virtual

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.

Reimplemented from ARDOUR::AudioBackend.

◆ enumerate_midi_devices()

std::vector<DeviceStatus> ARDOUR::AlsaAudioBackend::enumerate_midi_devices ( ) const

virtual

Detailed MIDI device list - if available

Implements ARDOUR::AudioBackend.

◆ enumerate_midi_options()

std::vector<std::string> ARDOUR::AlsaAudioBackend::enumerate_midi_options ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ enumerate_output_devices()

std::vector<DeviceStatus> ARDOUR::AlsaAudioBackend::enumerate_output_devices ( ) const

virtual

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.

Reimplemented from ARDOUR::AudioBackend.

◆ freewheel()

int ARDOUR::AlsaAudioBackend::freewheel ( bool start_stop )

virtual

While remaining connected to the device, and without changing its configuration, start (or stop) calling the process_callback of the engine without waiting for the device. Once process_callback() has returned, it will be called again immediately, thus allowing for faster-than-realtime processing.

All registered ports remain in existence and all connections remain unaltered. However, any physical ports should NOT be used by the process_callback() during freewheeling - the data behaviour is undefined.

If start_stop is true, begin this behaviour; otherwise cease this behaviour if it currently occuring, and return to calling process_callback() of the engine by waiting for the device.

Parameters

start_stop true to engage freewheel processing

Returns: zero on success, non-zero otherwise.

Implements ARDOUR::AudioBackend.

◆ get_buffer()

void* ARDOUR::AlsaAudioBackend::get_buffer	(	PortHandle	port,
		pframes_t	off
	)

virtual

Return the address of the memory area where data for the port can be written (if the port has the PortFlag IsOutput set) or read (if the port has the PortFlag IsInput set).

The return value is untyped because buffers containing different data depending on the port type.

Parameters

port	PortHandle
off	memory offset

Returns: pointer to raw memory area

Implements ARDOUR::PortEngine.

◆ get_connections()

int ARDOUR::AlsaAudioBackend::get_connections	(	PortEngine::PortHandle	port,
		std::vector< std::string > &	names,
		bool	process_callback_safe
	)

inlinevirtual

Place the names of all ports connected to the port named by port into names .

Parameters

port	PortHandle
names	array or returned port-names
process_callback_safe	true if this method is not called from rt-context of backend callbacks

Returns: number of connections found

Implements ARDOUR::PortEngine.

Definition at line 246 of file alsa_audiobackend.h.

◆ get_latency_range()

LatencyRange ARDOUR::AlsaAudioBackend::get_latency_range	(	PortHandle	port,
		bool	for_playback
	)

virtual

Return the latency range for the port referred to by port . The playback range will be returned if for_playback is true, otherwise the capture range will be returned.

Parameters

port	The PortHandle to query
for_playback	When true, playback (downstream) latency is queried, false for capture (upstream) latency.

Implements ARDOUR::PortEngine.

◆ get_midi_event_count()

uint32_t ARDOUR::AlsaAudioBackend::get_midi_event_count ( void * port_buffer )

virtual

Query the number of MIDI events in the data at port_buffer

Parameters

port_buffer the midi-port buffer

Returns: the number of MIDI events in the data at port_buffer

Implements ARDOUR::PortEngine.

◆ get_physical_inputs()

void ARDOUR::AlsaAudioBackend::get_physical_inputs	(	DataType	type,
		std::vector< std::string > &	names
	)

inlinevirtual

Store into names the names of all ports with the IsInput and IsPhysical flags set, that handle data of type type .

This can be used to discover inputs associated with hardware devices.

Implements ARDOUR::PortEngine.

Definition at line 224 of file alsa_audiobackend.h.

◆ get_physical_outputs()

void ARDOUR::AlsaAudioBackend::get_physical_outputs	(	DataType	type,
		std::vector< std::string > &	names
	)

inlinevirtual

Store into names the names of all ports with the IsOutput and IsPhysical flag set, that handle data of type type .

This can be used to discover outputs associated with hardware devices.

Parameters

type	Data-type to lookup
names	return value to populate with names

Implements ARDOUR::PortEngine.

Definition at line 223 of file alsa_audiobackend.h.

◆ get_port_by_name()

PortEngine::PortPtr ARDOUR::AlsaAudioBackend::get_port_by_name ( std::string const & name ) const

inlinevirtual

Return a reference to a port with the fullname name .

Parameters

name	Full port-name to lookup

Returns: PortHandle if lookup was successful, or an "empty" PortHandle (analogous to a null pointer) if no such port exists.

Implements ARDOUR::PortEngine.

Definition at line 231 of file alsa_audiobackend.h.

◆ get_port_flags()

PortFlags ARDOUR::AlsaAudioBackend::get_port_flags ( PortEngine::PortHandle port ) const

inlinevirtual

Query port-flags

Parameters

port	PortHandle

Returns: the flags of the port referred to by port . If the port does not exist, return PortFlags (0)

Implements ARDOUR::PortEngine.

Definition at line 230 of file alsa_audiobackend.h.

◆ get_port_name()

std::string ARDOUR::AlsaAudioBackend::get_port_name ( PortEngine::PortHandle port ) const

inlinevirtual

Query port name

Parameters

port	PortHandle

Returns: the name of the port referred to by port . If the port does not exist, return an empty string.

Implements ARDOUR::PortEngine.

Definition at line 229 of file alsa_audiobackend.h.

◆ get_port_property()

int ARDOUR::AlsaAudioBackend::get_port_property	(	PortEngine::PortHandle	,
		const std::string &	key,
		std::string &	value,
		std::string &	type
	)		const

inlinevirtual

Return the port-property value and type for a given key. (eg query a human readable port name)

The API follows jack_get_property():

Parameters

key	The key of the property to retrieve
value	Set to the value of the property if found
type	The type of the property if set ( Type of data, either a MIME type or URI. If type is empty, the data is assumed to be a UTF-8 encoded string.

Returns: 0 on success, -1 if the subject has no key property.

for available keys, see https://github.com/jackaudio/headers/blob/master/metadata.h https://github.com/drobilla/jackey/blob/master/jackey.h

Reimplemented from ARDOUR::PortEngine.

Definition at line 232 of file alsa_audiobackend.h.

◆ get_ports()

int ARDOUR::AlsaAudioBackend::get_ports	(	const std::string &	port_name_pattern,
		DataType	type,
		PortFlags	flags,
		std::vector< std::string > &	ports
	)		const

inlinevirtual

Find the set of ports whose names, types and flags match specified values, place the names of each port into ports .

Parameters

port_name_pattern	match by given pattern. To avoid selecting by name, pass an empty string.
type	filter by given type; pass DataType::NIL to match all types.
flags	filter by flags, pass PortFlags (0) to avoid selecting by flags.
ports	array filled with matching port-names

Returns: the count of the number found

Implements ARDOUR::PortEngine.

Definition at line 234 of file alsa_audiobackend.h.

◆ in_process_thread()

bool ARDOUR::AlsaAudioBackend::in_process_thread ( )

virtual

Return true if execution context is in a backend thread

Implements ARDOUR::AudioBackend.

◆ input_device_name()

std::string ARDOUR::AlsaAudioBackend::input_device_name ( ) const

virtual

Reimplemented from ARDOUR::AudioBackend.

◆ interleaved()

bool ARDOUR::AlsaAudioBackend::interleaved ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ is_realtime()

bool ARDOUR::AlsaAudioBackend::is_realtime ( ) const

virtual

Return true if the callback from the underlying mechanism/API (CoreAudio, JACK, ASIO etc.) occurs in a thread subject to realtime constraints. Return false otherwise.

Implements ARDOUR::AudioBackend.

◆ join_process_threads()

int ARDOUR::AlsaAudioBackend::join_process_threads ( )

virtual

Wait for all processing threads to exit.

Return zero on success, non-zero on failure.

Implements ARDOUR::AudioBackend.

◆ launch_control_app()

void ARDOUR::AlsaAudioBackend::launch_control_app ( )

inlinevirtual

Launch the control app for the currently in-use or selected device. May do nothing if the control app is undefined or cannot be launched.

Implements ARDOUR::AudioBackend.

Definition at line 183 of file alsa_audiobackend.h.

◆ listen_for_midi_device_changes()

bool ARDOUR::AlsaAudioBackend::listen_for_midi_device_changes ( )

private

◆ main_process_thread()

void* ARDOUR::AlsaAudioBackend::main_process_thread ( )

◆ match_input_output_devices_or_none()

bool ARDOUR::AlsaAudioBackend::match_input_output_devices_or_none ( ) const

inlinevirtual

Reimplemented from ARDOUR::AudioBackend.

Definition at line 131 of file alsa_audiobackend.h.

◆ midi_clear()

void ARDOUR::AlsaAudioBackend::midi_clear ( void * port_buffer )

virtual

Clear the buffer at port_buffer of all MIDI events.

After a call to this method, an immediate, subsequent call to get_midi_event_count with the same port_buffer argument must return zero.

Parameters

port_buffer the buffer to clear

Implements ARDOUR::PortEngine.

◆ midi_device_enabled()

bool ARDOUR::AlsaAudioBackend::midi_device_enabled ( std::string const ) const

virtual

query if a midi-device is enabled

Implements ARDOUR::AudioBackend.

◆ midi_device_info()

struct AlsaMidiDeviceInfo* ARDOUR::AlsaAudioBackend::midi_device_info ( std::string const ) const

private

◆ midi_device_thread()

void ARDOUR::AlsaAudioBackend::midi_device_thread ( )

private

◆ midi_event_get()

int ARDOUR::AlsaAudioBackend::midi_event_get	(	pframes_t &	timestamp,
		size_t &	size,
		uint8_t const **	buf,
		void *	port_buffer,
		uint32_t	event_index
	)

virtual

Retrieve a MIDI event from the data at port_buffer . The event number to be retrieved is given by event_index (a value of zero indicates that the first event in the port_buffer should be retrieved).

The data associated with the event will be copied into the buffer at buf and the number of bytes written will be stored in size . The timestamp of the event (which is always relative to the start of the current process cycle, in samples) will be stored in timestamp .

Parameters

timestamp	time in samples relative to the current cycle start
size	number of bytes read into `buf`
buf	raw MIDI data
port_buffer	the midi-port buffer
event_index	index of event to retrieve

Returns: 0 on success, -1 otherwise

Implements ARDOUR::PortEngine.

◆ midi_event_put()

int ARDOUR::AlsaAudioBackend::midi_event_put	(	void *	port_buffer,
		pframes_t	timestamp,
		const uint8_t *	buffer,
		size_t	size
	)

virtual

Place a MIDI event consisting of size bytes copied from the data at buffer into the port buffer referred to by port_buffer . The MIDI event will be marked with a time given by timestamp .

Events must be added monotonically to a port buffer. An attempt to add a non-monotonic event (e.g. out-of-order) will cause this method to return a failure status.

Parameters

port_buffer	the midi-port buffer
timestamp	time in samples relative to the current cycle start
buffer	raw MIDI data to emplace
size	number of bytes of `buffer`

Returns: zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

◆ midi_option()

std::string ARDOUR::AlsaAudioBackend::midi_option ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ monitoring_input()

bool ARDOUR::AlsaAudioBackend::monitoring_input ( PortHandle port )

virtual

Query status of hardware monitoring for given port

Parameters

port	PortHandle to test

Returns: true if input monitoring is enabled for the hardware channel represented by the port referred to by port . Return false otherwise.

Implements ARDOUR::PortEngine.

◆ my_name()

const std::string& ARDOUR::AlsaAudioBackend::my_name ( ) const

virtual

Return the name of this process as used by the port manager when naming ports.

Implements ARDOUR::PortEngine.

◆ n_physical_inputs()

ChanCount ARDOUR::AlsaAudioBackend::n_physical_inputs ( ) const

inlinevirtual

Returns: the total count (possibly mixed between different data types) of the number of ports with the IsPhysical and IsInput flags set.

Implements ARDOUR::PortEngine.

Definition at line 226 of file alsa_audiobackend.h.

◆ n_physical_outputs()

ChanCount ARDOUR::AlsaAudioBackend::n_physical_outputs ( ) const

inlinevirtual

Returns: the total count (possibly mixed between different data types) of the number of ports with the IsPhysical and IsOutput flags set.

Implements ARDOUR::PortEngine.

Definition at line 225 of file alsa_audiobackend.h.

◆ name()

std::string ARDOUR::AlsaAudioBackend::name ( ) const

virtual

Return the name of this backend.

Should use a well-known, unique term. Expected examples might include "JACK", "CoreAudio", "ASIO" etc.

Implements ARDOUR::AudioBackend.

◆ output_device_name()

std::string ARDOUR::AlsaAudioBackend::output_device_name ( ) const

virtual

Reimplemented from ARDOUR::AudioBackend.

◆ period_size()

uint32_t ARDOUR::AlsaAudioBackend::period_size ( ) const

virtual

Reimplemented from ARDOUR::AudioBackend.

◆ physically_connected()

bool ARDOUR::AlsaAudioBackend::physically_connected	(	PortEngine::PortHandle	port,
		bool	process_callback_safe
	)

inlinevirtual

Test if given port is connected to physical I/O ports.

Parameters

port	PortHandle of source port to test
process_callback_safe	true if this method is not called from rt-context of backend callbacks

Returns: true if the port referred to by port has any connections to ports marked with the PortFlag IsPhysical. Return false otherwise.

Implements ARDOUR::PortEngine.

Definition at line 245 of file alsa_audiobackend.h.

◆ port_data_type()

DataType ARDOUR::AlsaAudioBackend::port_data_type ( PortEngine::PortHandle port ) const

inlinevirtual

Lookup data type of a port

Parameters

port	PortHandle of the port to lookup.

Returns: the Ardour data type handled by the port referred to by port . DataType::NIL is returned if the port does not exist.

Implements ARDOUR::PortEngine.

Definition at line 235 of file alsa_audiobackend.h.

◆ port_factory()

BackendPort* ARDOUR::AlsaAudioBackend::port_factory	(	std::string const &	name,
		ARDOUR::DataType	dt,
		ARDOUR::PortFlags	flags
	)

privatevirtual

Implements ARDOUR::PortEngineSharedImpl.

◆ port_is_physical()

bool ARDOUR::AlsaAudioBackend::port_is_physical ( PortEngine::PortHandle port ) const

inlinevirtual

Return true if the port referred to by port has the IsPhysical flag set. Return false otherwise.

Parameters

port	PortHandle to query

Implements ARDOUR::PortEngine.

Definition at line 222 of file alsa_audiobackend.h.

◆ port_name_size()

uint32_t ARDOUR::AlsaAudioBackend::port_name_size ( ) const

inlinevirtual

Return the maximum size of a port name

Implements ARDOUR::PortEngine.

Definition at line 227 of file alsa_audiobackend.h.

◆ private_handle()

void* ARDOUR::AlsaAudioBackend::private_handle ( ) const

virtual

Return a private, type-free pointer to any data that might be useful to a concrete implementation

Implements ARDOUR::PortEngine.

◆ process_thread_count()

uint32_t ARDOUR::AlsaAudioBackend::process_thread_count ( )

virtual

Return number of processing threads

Implements ARDOUR::AudioBackend.

◆ raw_buffer_size()

size_t ARDOUR::AlsaAudioBackend::raw_buffer_size ( DataType t )

virtual

Implements ARDOUR::AudioBackend.

◆ register_port()

PortEngine::PortPtr ARDOUR::AlsaAudioBackend::register_port	(	const std::string &	shortname,
		ARDOUR::DataType	type,
		ARDOUR::PortFlags	flags
	)

inlinevirtual

Create a new port whose fullname will be the conjunction of my_name(), ":" and shortname . The port will handle data specified by type and will have the flags given by flags . If successful,

Parameters

shortname	Name of port to create
type	type of port to create
flags	flags of the port to create

Returns: a reference to the port, otherwise return a null pointer.

Implements ARDOUR::PortEngine.

Definition at line 236 of file alsa_audiobackend.h.

◆ register_system_audio_ports()

int ARDOUR::AlsaAudioBackend::register_system_audio_ports ( )

private

◆ register_system_midi_ports()

int ARDOUR::AlsaAudioBackend::register_system_midi_ports ( const std::string device = "" )

private

◆ request_input_monitoring()

int ARDOUR::AlsaAudioBackend::request_input_monitoring	(	PortHandle	port,
		bool	yn
	)

virtual

Increment or decrement the number of requests to monitor the input of the hardware channel represented by the port referred to by port .

If the number of requests rises above zero, input monitoring will be enabled (if can_monitor_input() returns true for the implementation).

If the number of requests falls to zero, input monitoring will be disabled (if can_monitor_input() returns true for the implementation)

Parameters

port	PortHandle
yn	true to enable hardware monitoring, false to disable

Returns: 0 on success, -1 otherwise

Implements ARDOUR::PortEngine.

◆ reset_device()

int ARDOUR::AlsaAudioBackend::reset_device ( )

inlinevirtual

Reset device.

Return zero if successful, negative values on error

Implements ARDOUR::AudioBackend.

Definition at line 164 of file alsa_audiobackend.h.

◆ sample_rate()

float ARDOUR::AlsaAudioBackend::sample_rate ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ sample_time()

samplepos_t ARDOUR::AlsaAudioBackend::sample_time ( )

virtual

return the time according to the sample clock in use, measured in samples since an arbitrary zero time in the past. The value should increase monotonically and linearly, without interruption from any source (including CPU frequency scaling).

It is extremely likely that any implementation will use a DLL, since this function can be called from any thread, at any time, and must be able to accurately determine the correct sample time.

Can be called from any thread.

Implements ARDOUR::AudioBackend.

◆ sample_time_at_cycle_start()

samplepos_t ARDOUR::AlsaAudioBackend::sample_time_at_cycle_start ( )

virtual

Return the time according to the sample clock in use when the most recent buffer process cycle began. Can be called from any thread.

Implements ARDOUR::AudioBackend.

◆ samples_since_cycle_start()

pframes_t ARDOUR::AlsaAudioBackend::samples_since_cycle_start ( )

virtual

Return the time since the current buffer process cycle started, in samples, according to the sample clock in use.

Can ONLY be called from within a process() callback tree (which implies that it can only be called by a process thread)

Implements ARDOUR::AudioBackend.

◆ set_buffer_size()

int ARDOUR::AlsaAudioBackend::set_buffer_size ( uint32_t )

virtual

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).

Implements ARDOUR::AudioBackend.

◆ set_device_name()

int ARDOUR::AlsaAudioBackend::set_device_name ( const std::string & )

virtual

Set the name of the device to be used

Implements ARDOUR::AudioBackend.

◆ set_input_device_name()

int ARDOUR::AlsaAudioBackend::set_input_device_name ( const std::string & )

virtual

Set the name of the input device to be used if using separate input/output devices.

See also: use_separate_input_and_output_devices()

Reimplemented from ARDOUR::AudioBackend.

◆ set_interleaved()

int ARDOUR::AlsaAudioBackend::set_interleaved ( bool yn )

virtual

Set the preferred underlying hardware data layout. If yn is true, then the hardware will interleave samples for successive channels; otherwise, the hardware will store samples for a single channel contiguously.

Setting this does not change the fact that all data streams to and from Ports are mono (essentially, non-interleaved)

Implements ARDOUR::AudioBackend.

◆ set_latency_range()

void ARDOUR::AlsaAudioBackend::set_latency_range	(	PortHandle	port,
		bool	for_playback,
		LatencyRange	r
	)

virtual

Set the latency range for the port referred to by port to r . The playback range will be set if for_playback is true, otherwise the capture range will be set.

Parameters

port	PortHandle to operate on
for_playback	When true, playback latency is set: How long will it be until the signal arrives at the edge of the process graph. When false the capture latency is set: ow long has it been since the signal arrived at the edge of the process graph.
r	min/max latency for given port.

Implements ARDOUR::PortEngine.

◆ set_midi_device_enabled()

int ARDOUR::AlsaAudioBackend::set_midi_device_enabled	(	std::string const	,
		bool
	)

virtual

mark a midi-devices as enabled

Implements ARDOUR::AudioBackend.

◆ set_midi_option()

int ARDOUR::AlsaAudioBackend::set_midi_option ( const std::string & )

virtual

Implements ARDOUR::AudioBackend.

◆ set_output_device_name()

int ARDOUR::AlsaAudioBackend::set_output_device_name ( const std::string & )

virtual

Set the name of the output device to be used if using separate input/output devices.

See also: use_separate_input_and_output_devices()

Reimplemented from ARDOUR::AudioBackend.

◆ set_peridod_size()

int ARDOUR::AlsaAudioBackend::set_peridod_size ( uint32_t )

virtual

Set the period size to be used. must be called before starting the backend.

Reimplemented from ARDOUR::AudioBackend.

◆ set_port_name()

int ARDOUR::AlsaAudioBackend::set_port_name	(	PortEngine::PortHandle	port,
		const std::string &	name
	)

inlinevirtual

Set/rename port

Parameters

port	PortHandle to operate on
name	new name to use for this port

Returns: zero if successful, non-zero otherwise

Implements ARDOUR::PortEngine.

Definition at line 228 of file alsa_audiobackend.h.

◆ set_port_property()

int ARDOUR::AlsaAudioBackend::set_port_property	(	PortEngine::PortHandle	,
		const std::string &	key,
		const std::string &	value,
		const std::string &	type
	)

inlinevirtual

Set the port-property value and type for a given key

The API follows jack_set_property():

Parameters

key	The key of the property.
value	The value of the property.
type	The type of the property.

Returns: 0 on success, -1 on error

Reimplemented from ARDOUR::PortEngine.

Definition at line 233 of file alsa_audiobackend.h.

◆ set_sample_rate()

int ARDOUR::AlsaAudioBackend::set_sample_rate ( float )

virtual

Set the sample rate to be used

Implements ARDOUR::AudioBackend.

◆ set_systemic_input_latency()

int ARDOUR::AlsaAudioBackend::set_systemic_input_latency ( uint32_t )

virtual

Set the (additional) input latency that cannot be determined via the implementation's underlying code (e.g. latency from external D-A/D-A converters. Units are samples.

Implements ARDOUR::AudioBackend.

◆ set_systemic_midi_input_latency()

int ARDOUR::AlsaAudioBackend::set_systemic_midi_input_latency	(	std::string const	,
		uint32_t
	)

virtual

Set the (additional) input latency for a specific midi device, or if the identifier is empty, apply to all midi devices.

Implements ARDOUR::AudioBackend.

◆ set_systemic_midi_output_latency()

int ARDOUR::AlsaAudioBackend::set_systemic_midi_output_latency	(	std::string const	,
		uint32_t
	)

virtual

Set the (additional) output latency for a specific midi device, or if the identifier is empty, apply to all midi devices.

Implements ARDOUR::AudioBackend.

◆ set_systemic_output_latency()

int ARDOUR::AlsaAudioBackend::set_systemic_output_latency ( uint32_t )

virtual

Set the (additional) output latency that cannot be determined via the implementation's underlying code (e.g. latency from external D-A/D-A converters. Units are samples.

Implements ARDOUR::AudioBackend.

◆ stop()

int ARDOUR::AlsaAudioBackend::stop ( )

virtual

Stop using the device currently in use.

If the function is successfully called, no subsequent calls to the process_callback() of engine will be made after the function returns, until parameters are reset and start() are called again.

The backend is considered to be un-configured after a successful return, and requires calls to set hardware parameters before it can be start()-ed again. See pause() for a way to avoid this. stop() should only be used when reconfiguration is required OR when there are no plans to use the backend in the future with a reconfiguration.

Return zero if successful, 1 if the device is not in use, negative values on error

Implements ARDOUR::AudioBackend.

◆ stop_listen_for_midi_device_changes()

void ARDOUR::AlsaAudioBackend::stop_listen_for_midi_device_changes ( )

private

◆ systemic_input_latency()

uint32_t ARDOUR::AlsaAudioBackend::systemic_input_latency ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ systemic_midi_input_latency()

uint32_t ARDOUR::AlsaAudioBackend::systemic_midi_input_latency ( std::string const ) const

virtual

Implements ARDOUR::AudioBackend.

◆ systemic_midi_output_latency()

uint32_t ARDOUR::AlsaAudioBackend::systemic_midi_output_latency ( std::string const ) const

virtual

Implements ARDOUR::AudioBackend.

◆ systemic_output_latency()

uint32_t ARDOUR::AlsaAudioBackend::systemic_output_latency ( ) const

virtual

Implements ARDOUR::AudioBackend.

◆ unregister_port()

void ARDOUR::AlsaAudioBackend::unregister_port ( PortHandle ph )

inlinevirtual

Reimplemented from ARDOUR::PortEngineSharedImpl.

Definition at line 237 of file alsa_audiobackend.h.

◆ update_devices()

bool ARDOUR::AlsaAudioBackend::update_devices ( )

inlinevirtual

Request an update to the list of devices returned in the enumerations. The Backend must return true from can_request_update_devices to support this interface.

Returns: true if the devices were updated

Reimplemented from ARDOUR::AudioBackend.

Definition at line 150 of file alsa_audiobackend.h.

◆ update_latencies()

void ARDOUR::AlsaAudioBackend::update_latencies ( )

virtual

Implements ARDOUR::AudioBackend.

◆ update_system_port_latencies()

void ARDOUR::AlsaAudioBackend::update_system_port_latencies ( )

privatevirtual

Reimplemented from ARDOUR::PortEngineSharedImpl.

◆ update_systemic_audio_latencies()

void ARDOUR::AlsaAudioBackend::update_systemic_audio_latencies ( )

private

◆ update_systemic_midi_latencies()

void ARDOUR::AlsaAudioBackend::update_systemic_midi_latencies ( )

private

◆ use_separate_input_and_output_devices()

bool ARDOUR::AlsaAudioBackend::use_separate_input_and_output_devices ( ) const

inlinevirtual

An optional alternate interface for backends to provide a facility to select separate input and output devices.

If a backend returns true then enumerate_input_devices() and enumerate_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().

Reimplemented from ARDOUR::AudioBackend.

Definition at line 130 of file alsa_audiobackend.h.

Member Data Documentation

◆ _active

bool ARDOUR::AlsaAudioBackend::_active

private

Definition at line 277 of file alsa_audiobackend.h.

◆ _device_port_mutex

pthread_mutex_t ARDOUR::AlsaAudioBackend::_device_port_mutex

private

Definition at line 332 of file alsa_audiobackend.h.

◆ _device_reservation

AlsaDeviceReservation ARDOUR::AlsaAudioBackend::_device_reservation

private

Definition at line 297 of file alsa_audiobackend.h.

◆ _dsp_load

float ARDOUR::AlsaAudioBackend::_dsp_load

private

Definition at line 335 of file alsa_audiobackend.h.

◆ _dsp_load_calc

ARDOUR::DSPLoadCalculator ARDOUR::AlsaAudioBackend::_dsp_load_calc

private

Definition at line 336 of file alsa_audiobackend.h.

◆ _duplex_audio_device_status

std::vector<AudioBackend::DeviceStatus> ARDOUR::AlsaAudioBackend::_duplex_audio_device_status

staticprivate

Definition at line 287 of file alsa_audiobackend.h.

◆ _freewheel

bool ARDOUR::AlsaAudioBackend::_freewheel

private

Definition at line 278 of file alsa_audiobackend.h.

◆ _freewheeling

bool ARDOUR::AlsaAudioBackend::_freewheeling

private

Definition at line 279 of file alsa_audiobackend.h.

◆ _input_audio_device

std::string ARDOUR::AlsaAudioBackend::_input_audio_device

mutableprivate

Definition at line 292 of file alsa_audiobackend.h.

◆ _input_audio_device_info

ARDOUR::ALSADeviceInfo ARDOUR::AlsaAudioBackend::_input_audio_device_info

staticprivate

Definition at line 289 of file alsa_audiobackend.h.

◆ _input_audio_device_status

std::vector<AudioBackend::DeviceStatus> ARDOUR::AlsaAudioBackend::_input_audio_device_status

staticprivate

Definition at line 285 of file alsa_audiobackend.h.

◆ _instance_name

std::string ARDOUR::AlsaAudioBackend::_instance_name

private

Definition at line 273 of file alsa_audiobackend.h.

◆ _last_process_start

uint64_t ARDOUR::AlsaAudioBackend::_last_process_start

private

Definition at line 282 of file alsa_audiobackend.h.

◆ _main_thread

pthread_t ARDOUR::AlsaAudioBackend::_main_thread

private

Definition at line 338 of file alsa_audiobackend.h.

◆ _max_buffer_size

size_t ARDOUR::AlsaAudioBackend::_max_buffer_size

staticprivate

Definition at line 303 of file alsa_audiobackend.h.

◆ _measure_latency

bool ARDOUR::AlsaAudioBackend::_measure_latency

private

Definition at line 280 of file alsa_audiobackend.h.

◆ _midi_device_status

std::vector<AudioBackend::DeviceStatus> ARDOUR::AlsaAudioBackend::_midi_device_status

staticprivate

Definition at line 288 of file alsa_audiobackend.h.

◆ _midi_device_thread_active

bool ARDOUR::AlsaAudioBackend::_midi_device_thread_active

private

Definition at line 330 of file alsa_audiobackend.h.

◆ _midi_device_thread_id

pthread_t ARDOUR::AlsaAudioBackend::_midi_device_thread_id

private

Definition at line 329 of file alsa_audiobackend.h.

◆ _midi_devices

std::map<std::string, struct AlsaMidiDeviceInfo *> ARDOUR::AlsaAudioBackend::_midi_devices

mutableprivate

Definition at line 320 of file alsa_audiobackend.h.

◆ _midi_driver_option

std::string ARDOUR::AlsaAudioBackend::_midi_driver_option

private

Definition at line 294 of file alsa_audiobackend.h.

◆ _midi_options

std::vector<std::string> ARDOUR::AlsaAudioBackend::_midi_options

staticprivate

Definition at line 284 of file alsa_audiobackend.h.

◆ _output_audio_device

std::string ARDOUR::AlsaAudioBackend::_output_audio_device

mutableprivate

Definition at line 293 of file alsa_audiobackend.h.

◆ _output_audio_device_info

ARDOUR::ALSADeviceInfo ARDOUR::AlsaAudioBackend::_output_audio_device_info

staticprivate

Definition at line 290 of file alsa_audiobackend.h.

◆ _output_audio_device_status

std::vector<AudioBackend::DeviceStatus> ARDOUR::AlsaAudioBackend::_output_audio_device_status

staticprivate

Definition at line 286 of file alsa_audiobackend.h.

◆ _pcmi

Alsa_pcmi* ARDOUR::AlsaAudioBackend::_pcmi

private

Definition at line 274 of file alsa_audiobackend.h.

◆ _periods_per_cycle

size_t ARDOUR::AlsaAudioBackend::_periods_per_cycle

private

Definition at line 302 of file alsa_audiobackend.h.

◆ _processed_samples

samplecnt_t ARDOUR::AlsaAudioBackend::_processed_samples

private

Definition at line 337 of file alsa_audiobackend.h.

◆ _rmidi_in

std::vector<AlsaMidiIn *> ARDOUR::AlsaAudioBackend::_rmidi_in

private

Definition at line 365 of file alsa_audiobackend.h.

◆ _rmidi_out

std::vector<AlsaMidiOut *> ARDOUR::AlsaAudioBackend::_rmidi_out

private

Definition at line 364 of file alsa_audiobackend.h.

◆ _run

bool ARDOUR::AlsaAudioBackend::_run

private

Definition at line 276 of file alsa_audiobackend.h.

◆ _samplerate

float ARDOUR::AlsaAudioBackend::_samplerate

private

Definition at line 300 of file alsa_audiobackend.h.

◆ _samples_per_period

size_t ARDOUR::AlsaAudioBackend::_samples_per_period

private

Definition at line 301 of file alsa_audiobackend.h.

◆ _slaves

AudioSlaves ARDOUR::AlsaAudioBackend::_slaves

private

Definition at line 415 of file alsa_audiobackend.h.

◆ _systemic_audio_input_latency

uint32_t ARDOUR::AlsaAudioBackend::_systemic_audio_input_latency

private

Definition at line 305 of file alsa_audiobackend.h.

◆ _systemic_audio_output_latency

uint32_t ARDOUR::AlsaAudioBackend::_systemic_audio_output_latency

private

Definition at line 306 of file alsa_audiobackend.h.

◆ _t0

double ARDOUR::AlsaAudioBackend::_t0

private

Definition at line 341 of file alsa_audiobackend.h.

◆ _t1

double ARDOUR::AlsaAudioBackend::_t1

private

Definition at line 341 of file alsa_audiobackend.h.

◆ _threads

std::vector<pthread_t> ARDOUR::AlsaAudioBackend::_threads

private

Definition at line 345 of file alsa_audiobackend.h.

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

alsa_audiobackend.h

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ AudioSlaves

Constructor & Destructor Documentation

◆ AlsaAudioBackend()

◆ ~AlsaAudioBackend()

Member Function Documentation

◆ _midi_device_thread()

◆ _start()

◆ add_slave()

◆ alsa_process_thread()

◆ auto_update_midi_devices()

◆ available_buffer_sizes()

◆ available_buffer_sizes2()

◆ available_period_sizes()

◆ available_sample_rates()

◆ available_sample_rates2()

◆ buffer_size()

◆ can_change_buffer_size_when_running()

◆ can_change_sample_rate_when_running()

◆ can_change_systemic_latency_when_running()

◆ can_measure_systemic_latency()

◆ can_monitor_input()

◆ can_request_update_devices()

◆ can_set_period_size()

◆ can_set_systemic_midi_latencies()

◆ connect() [1/2]

◆ connect() [2/2]

◆ connected()

◆ connected_to()

◆ control_app_name()

◆ create_process_thread()

◆ device_name()

◆ disconnect() [1/2]

◆ disconnect() [2/2]

◆ disconnect_all()

◆ dsp_load()

◆ ensure_input_monitoring()

◆ enumerate_devices()

◆ enumerate_input_devices()

◆ enumerate_midi_devices()

◆ enumerate_midi_options()

◆ enumerate_output_devices()

◆ freewheel()

◆ get_buffer()

◆ get_connections()

◆ get_latency_range()

◆ get_midi_event_count()

◆ get_physical_inputs()

◆ get_physical_outputs()

◆ get_port_by_name()

◆ get_port_flags()

◆ get_port_name()

◆ get_port_property()

◆ get_ports()

◆ in_process_thread()

◆ input_device_name()

◆ interleaved()

◆ is_realtime()

◆ join_process_threads()

◆ launch_control_app()

◆ listen_for_midi_device_changes()

◆ main_process_thread()

◆ match_input_output_devices_or_none()

◆ midi_clear()

◆ midi_device_enabled()

◆ midi_device_info()

◆ midi_device_thread()

◆ midi_event_get()

◆ midi_event_put()

◆ midi_option()