Ardour  9.0-pre0-582-g084a23a80d
ARDOUR::PortAudioBackend Class Reference

#include <portaudio_backend.h>

Inheritance diagram for ARDOUR::PortAudioBackend:
[legend]

Classes

struct  ThreadData
 

Public Member Functions

 PortAudioBackend (AudioEngine &e, AudioBackendInfo &info)
 
 ~PortAudioBackend ()
 
std::string name () const
 
bool is_realtime () const
 
bool requires_driver_selection () const
 
std::string driver_name () const
 
std::vector< std::string > enumerate_drivers () const
 
int set_driver (const std::string &)
 
bool can_request_update_devices ()
 
bool update_devices ()
 
bool can_use_buffered_io ()
 
void set_use_buffered_io (bool)
 
bool get_use_buffered_io ()
 
bool use_separate_input_and_output_devices () const
 
std::vector< DeviceStatusenumerate_devices () const
 
std::vector< DeviceStatusenumerate_input_devices () const
 
std::vector< DeviceStatusenumerate_output_devices () const
 
std::vector< float > available_sample_rates (const std::string &device) const
 
std::vector< uint32_t > available_buffer_sizes (const std::string &device) const
 
bool can_change_sample_rate_when_running () const
 
bool can_change_buffer_size_when_running () const
 
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_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
 
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_measure_systemic_latency () 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< DeviceStatusenumerate_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 * blocking_process_thread ()
 
void * freewheel_process_thread ()
 
- Public Member Functions inherited from ARDOUR::AudioBackend
 AudioBackend (AudioEngine &e, AudioBackendInfo &i)
 
virtual ~AudioBackend ()
 
AudioBackendInfoinfo () const
 
virtual bool is_jack () const
 
virtual int client_real_time_priority ()
 
virtual bool match_input_output_devices_or_none () const
 
virtual bool can_set_period_size () const
 
virtual std::vector< uint32_t > available_period_sizes (const std::string &driver, const std::string &device) const
 
virtual int set_peridod_size (uint32_t)
 
virtual std::vector< float > available_sample_rates2 (const std::string &input_device, const std::string &output_device) const
 
virtual float default_sample_rate () const
 
virtual std::vector< uint32_t > available_buffer_sizes2 (const std::string &input_device, const std::string &output_device) const
 
virtual uint32_t default_buffer_size (const std::string &device) const
 
virtual bool can_change_systemic_latency_when_running () const
 
virtual int drop_device ()
 
virtual uint32_t period_size () 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 ()
 
virtual void update_system_port_latencies ()
 
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 Member Functions

bool start_blocking_process_thread ()
 
bool stop_blocking_process_thread ()
 
bool blocking_process_freewheel ()
 
bool blocking_process_main (const float *interleaved_input_data, float *interleaved_output_data)
 
void process_port_connection_changes ()
 
void process_incoming_midi ()
 
void process_outgoing_midi ()
 
bool engine_halted ()
 
bool running ()
 
bool process_callback (const float *input, float *output, uint32_t sample_count, const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags)
 
bool start_freewheel_process_thread ()
 
bool stop_freewheel_process_thread ()
 
MidiDeviceInfomidi_device_info (const std::string &) const
 
int name_to_id (std::string) const
 
BackendPortport_factory (std::string const &name, ARDOUR::DataType dt, ARDOUR::PortFlags flags)
 
int register_system_audio_ports ()
 
int register_system_midi_ports (std::string const &device="")
 
void update_systemic_midi_latencies ()
 

Static Private Member Functions

static int portaudio_callback (const void *input, void *output, unsigned long frameCount, const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
 
static bool set_mmcss_pro_audio (HANDLE *task_handle)
 
static bool reset_mmcss (HANDLE task_handle)
 
static void * portaudio_process_thread (void *)
 

Private Attributes

std::string _instance_name
 
PortAudioIO_pcmio
 
WinMMEMidiIO_midiio
 
bool _run
 
bool _active
 
bool _use_blocking_api
 
bool _freewheel
 
bool _freewheeling
 
bool _freewheel_ack
 
bool _reinit_thread_callback
 
bool _measure_latency
 
int _freewheel_processed
 
ARDOUR::DSPLoadCalculator _dsp_calc
 
bool _freewheel_thread_active
 
pthread_mutex_t _freewheel_mutex
 
pthread_cond_t _freewheel_signal
 
uint64_t _cycle_count
 
uint64_t _total_deviation_us
 
uint64_t _max_deviation_us
 
CycleTimer _cycle_timer
 
uint64_t _last_cycle_start
 
std::string _input_audio_device
 
std::string _output_audio_device
 
std::string _midi_driver_option
 
float _samplerate
 
size_t _samples_per_period
 
uint32_t _systemic_audio_input_latency
 
uint32_t _systemic_audio_output_latency
 
float _dsp_load
 
samplecnt_t _processed_samples
 
pthread_t _main_blocking_thread
 
pthread_t _main_thread
 
pthread_t _pthread_freewheel
 
std::vector< pthread_t > _threads
 

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_midi_device_status
 
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< ProtoPortPortPtr
 
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, BackendPortPtrPortMap
 
typedef std::set< BackendPortPtr, SortByPortNamePortIndex
 
typedef std::set< BackendPortPtrPortRegistry
 
- Protected Attributes inherited from ARDOUR::AudioBackend
AudioBackendInfo_info
 
AudioEngineengine
 
- Protected Attributes inherited from ARDOUR::PortEngine
PortManagermanager
 
- 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 94 of file portaudio_backend.h.

Constructor & Destructor Documentation

◆ PortAudioBackend()

ARDOUR::PortAudioBackend::PortAudioBackend ( AudioEngine e,
AudioBackendInfo info 
)

◆ ~PortAudioBackend()

ARDOUR::PortAudioBackend::~PortAudioBackend ( )

Member Function Documentation

◆ _start()

int ARDOUR::PortAudioBackend::_start ( bool  for_latency_measurement)
protectedvirtual

Implements ARDOUR::AudioBackend.

◆ available_buffer_sizes()

std::vector<uint32_t> ARDOUR::PortAudioBackend::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_sample_rates()

std::vector<float> ARDOUR::PortAudioBackend::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.

◆ blocking_process_freewheel()

bool ARDOUR::PortAudioBackend::blocking_process_freewheel ( )
private

◆ blocking_process_main()

bool ARDOUR::PortAudioBackend::blocking_process_main ( const float *  interleaved_input_data,
float *  interleaved_output_data 
)
private

◆ blocking_process_thread()

void* ARDOUR::PortAudioBackend::blocking_process_thread ( )

◆ buffer_size()

uint32_t ARDOUR::PortAudioBackend::buffer_size ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ can_change_buffer_size_when_running()

bool ARDOUR::PortAudioBackend::can_change_buffer_size_when_running ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ can_change_sample_rate_when_running()

bool ARDOUR::PortAudioBackend::can_change_sample_rate_when_running ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ can_measure_systemic_latency()

bool ARDOUR::PortAudioBackend::can_measure_systemic_latency ( ) const
inlinevirtual

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

Implements ARDOUR::AudioBackend.

Definition at line 152 of file portaudio_backend.h.

◆ can_monitor_input()

bool ARDOUR::PortAudioBackend::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::PortAudioBackend::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 109 of file portaudio_backend.h.

◆ can_set_systemic_midi_latencies()

bool ARDOUR::PortAudioBackend::can_set_systemic_midi_latencies ( ) const
inlinevirtual

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

Implements ARDOUR::AudioBackend.

Definition at line 153 of file portaudio_backend.h.

◆ can_use_buffered_io()

bool ARDOUR::PortAudioBackend::can_use_buffered_io ( )
inlinevirtual
Returns
true if backend supports a blocking or buffered mode, false by default unless implemented by a derived class.

Reimplemented from ARDOUR::AudioBackend.

Definition at line 112 of file portaudio_backend.h.

◆ connect() [1/2]

int ARDOUR::PortAudioBackend::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
srcname of source port to connect
dstname of destination (sink) port
Returns
zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 213 of file portaudio_backend.h.

◆ connect() [2/2]

int ARDOUR::PortAudioBackend::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
srcPortHandle of source port to connect
dstPortHandle of destination (sink) port
Returns
zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 215 of file portaudio_backend.h.

◆ connected()

bool ARDOUR::PortAudioBackend::connected ( PortEngine::PortHandle  port,
bool  process_callback_safe 
)
inlinevirtual

Test if given port is connected

Parameters
portPortHandle of port to test
process_callback_safetrue 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 218 of file portaudio_backend.h.

◆ connected_to()

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

Test port connection

Parameters
portPortHandle of source port to test
namename of destination to test
process_callback_safetrue 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 219 of file portaudio_backend.h.

◆ control_app_name()

std::string ARDOUR::PortAudioBackend::control_app_name ( ) const
virtual

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.

◆ create_process_thread()

int ARDOUR::PortAudioBackend::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
funcprocess function to run

Implements ARDOUR::AudioBackend.

◆ device_name()

std::string ARDOUR::PortAudioBackend::device_name ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ disconnect() [1/2]

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

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

Parameters
srcname of source port to dis-connect to disconnect from
dstname of destination (sink) port to disconnect
Returns
zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 214 of file portaudio_backend.h.

◆ disconnect() [2/2]

int ARDOUR::PortAudioBackend::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
srcPortHandle of source port to disconnect from
dstPortHandle of destination (sink) port to disconnect
Returns
zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 216 of file portaudio_backend.h.

◆ disconnect_all()

int ARDOUR::PortAudioBackend::disconnect_all ( PortEngine::PortHandle  port)
inlinevirtual

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

Parameters
portPortHandle of port to disconnect
Returns
zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

Definition at line 217 of file portaudio_backend.h.

◆ driver_name()

std::string ARDOUR::PortAudioBackend::driver_name ( ) const
virtual

override this if this implementation returns true from requires_driver_selection()

Reimplemented from ARDOUR::AudioBackend.

◆ dsp_load()

float ARDOUR::PortAudioBackend::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.

◆ engine_halted()

bool ARDOUR::PortAudioBackend::engine_halted ( )
private

◆ ensure_input_monitoring()

int ARDOUR::PortAudioBackend::ensure_input_monitoring ( PortHandle  ,
bool   
)
virtual

Implements ARDOUR::PortEngine.

◆ enumerate_devices()

std::vector<DeviceStatus> ARDOUR::PortAudioBackend::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_drivers()

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

If the return value of requires_driver_selection() is true, then this function can return the list of known driver names.

If the return value of requires_driver_selection() is false, then this function should not be called. If it is called its return value is an empty vector of strings.

Reimplemented from ARDOUR::AudioBackend.

◆ enumerate_input_devices()

std::vector<DeviceStatus> ARDOUR::PortAudioBackend::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::PortAudioBackend::enumerate_midi_devices ( ) const
virtual

Detailed MIDI device list - if available

Implements ARDOUR::AudioBackend.

◆ enumerate_midi_options()

std::vector<std::string> ARDOUR::PortAudioBackend::enumerate_midi_options ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ enumerate_output_devices()

std::vector<DeviceStatus> ARDOUR::PortAudioBackend::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::PortAudioBackend::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_stoptrue to engage freewheel processing
Returns
zero on success, non-zero otherwise.

Implements ARDOUR::AudioBackend.

◆ freewheel_process_thread()

void* ARDOUR::PortAudioBackend::freewheel_process_thread ( )

◆ get_buffer()

void* ARDOUR::PortAudioBackend::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
portPortHandle
offmemory offset
Returns
pointer to raw memory area

Implements ARDOUR::PortEngine.

◆ get_connections()

int ARDOUR::PortAudioBackend::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
portPortHandle
namesarray or returned port-names
process_callback_safetrue if this method is not called from rt-context of backend callbacks
Returns
number of connections found

Implements ARDOUR::PortEngine.

Definition at line 221 of file portaudio_backend.h.

◆ get_latency_range()

LatencyRange ARDOUR::PortAudioBackend::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
portThe PortHandle to query
for_playbackWhen true, playback (downstream) latency is queried, false for capture (upstream) latency.

Implements ARDOUR::PortEngine.

◆ get_midi_event_count()

uint32_t ARDOUR::PortAudioBackend::get_midi_event_count ( void *  port_buffer)
virtual

Query the number of MIDI events in the data at port_buffer

Parameters
port_bufferthe midi-port buffer
Returns
the number of MIDI events in the data at port_buffer

Implements ARDOUR::PortEngine.

◆ get_physical_inputs()

void ARDOUR::PortAudioBackend::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 199 of file portaudio_backend.h.

◆ get_physical_outputs()

void ARDOUR::PortAudioBackend::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
typeData-type to lookup
namesreturn value to populate with names

Implements ARDOUR::PortEngine.

Definition at line 198 of file portaudio_backend.h.

◆ get_port_by_name()

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

Return a reference to a port with the fullname name .

Parameters
nameFull 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 206 of file portaudio_backend.h.

◆ get_port_flags()

PortFlags ARDOUR::PortAudioBackend::get_port_flags ( PortEngine::PortHandle  port) const
inlinevirtual

Query port-flags

Parameters
portPortHandle
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 205 of file portaudio_backend.h.

◆ get_port_name()

std::string ARDOUR::PortAudioBackend::get_port_name ( PortEngine::PortHandle  port) const
inlinevirtual

Query port name

Parameters
portPortHandle
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 204 of file portaudio_backend.h.

◆ get_port_property()

int ARDOUR::PortAudioBackend::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
keyThe key of the property to retrieve
valueSet to the value of the property if found
typeThe 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 207 of file portaudio_backend.h.

◆ get_ports()

int ARDOUR::PortAudioBackend::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_patternmatch by given pattern. To avoid selecting by name, pass an empty string.
typefilter by given type; pass DataType::NIL to match all types.
flagsfilter by flags, pass PortFlags (0) to avoid selecting by flags.
portsarray filled with matching port-names
Returns
the count of the number found

Implements ARDOUR::PortEngine.

Definition at line 209 of file portaudio_backend.h.

◆ get_use_buffered_io()

bool ARDOUR::PortAudioBackend::get_use_buffered_io ( )
inlinevirtual
Returns
Set the backend to use a blocking or buffered I/O mode, false by default unless implemented by a derived class.

Reimplemented from ARDOUR::AudioBackend.

Definition at line 114 of file portaudio_backend.h.

◆ in_process_thread()

bool ARDOUR::PortAudioBackend::in_process_thread ( )
virtual

Return true if execution context is in a backend thread

Implements ARDOUR::AudioBackend.

◆ input_device_name()

std::string ARDOUR::PortAudioBackend::input_device_name ( ) const
virtual

Reimplemented from ARDOUR::AudioBackend.

◆ interleaved()

bool ARDOUR::PortAudioBackend::interleaved ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ is_realtime()

bool ARDOUR::PortAudioBackend::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::PortAudioBackend::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::PortAudioBackend::launch_control_app ( )
virtual

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.

◆ midi_clear()

void ARDOUR::PortAudioBackend::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_bufferthe buffer to clear

Implements ARDOUR::PortEngine.

◆ midi_device_enabled()

bool ARDOUR::PortAudioBackend::midi_device_enabled ( std::string const  ) const
virtual

query if a midi-device is enabled

Implements ARDOUR::AudioBackend.

◆ midi_device_info()

MidiDeviceInfo* ARDOUR::PortAudioBackend::midi_device_info ( const std::string &  ) const
private

◆ midi_event_get()

int ARDOUR::PortAudioBackend::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
timestamptime in samples relative to the current cycle start
sizenumber of bytes read into buf
bufraw MIDI data
port_bufferthe midi-port buffer
event_indexindex of event to retrieve
Returns
0 on success, -1 otherwise

Implements ARDOUR::PortEngine.

◆ midi_event_put()

int ARDOUR::PortAudioBackend::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_bufferthe midi-port buffer
timestamptime in samples relative to the current cycle start
bufferraw MIDI data to emplace
sizenumber of bytes of buffer
Returns
zero on success, non-zero otherwise.

Implements ARDOUR::PortEngine.

◆ midi_option()

std::string ARDOUR::PortAudioBackend::midi_option ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ monitoring_input()

bool ARDOUR::PortAudioBackend::monitoring_input ( PortHandle  port)
virtual

Query status of hardware monitoring for given port

Parameters
portPortHandle 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::PortAudioBackend::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::PortAudioBackend::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 201 of file portaudio_backend.h.

◆ n_physical_outputs()

ChanCount ARDOUR::PortAudioBackend::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 200 of file portaudio_backend.h.

◆ name()

std::string ARDOUR::PortAudioBackend::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.

◆ name_to_id()

int ARDOUR::PortAudioBackend::name_to_id ( std::string  ) const
private

◆ output_device_name()

std::string ARDOUR::PortAudioBackend::output_device_name ( ) const
virtual

Reimplemented from ARDOUR::AudioBackend.

◆ physically_connected()

bool ARDOUR::PortAudioBackend::physically_connected ( PortEngine::PortHandle  port,
bool  process_callback_safe 
)
inlinevirtual

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

Parameters
portPortHandle of source port to test
process_callback_safetrue 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 220 of file portaudio_backend.h.

◆ port_data_type()

DataType ARDOUR::PortAudioBackend::port_data_type ( PortEngine::PortHandle  port) const
inlinevirtual

Lookup data type of a port

Parameters
portPortHandle 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 210 of file portaudio_backend.h.

◆ port_factory()

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

◆ port_is_physical()

bool ARDOUR::PortAudioBackend::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
portPortHandle to query

Implements ARDOUR::PortEngine.

Definition at line 197 of file portaudio_backend.h.

◆ port_name_size()

uint32_t ARDOUR::PortAudioBackend::port_name_size ( ) const
inlinevirtual

Return the maximum size of a port name

Implements ARDOUR::PortEngine.

Definition at line 202 of file portaudio_backend.h.

◆ portaudio_callback()

static int ARDOUR::PortAudioBackend::portaudio_callback ( const void *  input,
void *  output,
unsigned long  frameCount,
const PaStreamCallbackTimeInfo *  timeInfo,
PaStreamCallbackFlags  statusFlags,
void *  userData 
)
staticprivate

◆ portaudio_process_thread()

static void* ARDOUR::PortAudioBackend::portaudio_process_thread ( void *  )
staticprivate

◆ private_handle()

void* ARDOUR::PortAudioBackend::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_callback()

bool ARDOUR::PortAudioBackend::process_callback ( const float *  input,
float *  output,
uint32_t  sample_count,
const PaStreamCallbackTimeInfo *  timeInfo,
PaStreamCallbackFlags  statusFlags 
)
private

◆ process_incoming_midi()

void ARDOUR::PortAudioBackend::process_incoming_midi ( )
private

◆ process_outgoing_midi()

void ARDOUR::PortAudioBackend::process_outgoing_midi ( )
private

◆ process_port_connection_changes()

void ARDOUR::PortAudioBackend::process_port_connection_changes ( )
private

◆ process_thread_count()

uint32_t ARDOUR::PortAudioBackend::process_thread_count ( )
virtual

Return number of processing threads

Implements ARDOUR::AudioBackend.

◆ raw_buffer_size()

size_t ARDOUR::PortAudioBackend::raw_buffer_size ( DataType  t)
virtual

Implements ARDOUR::AudioBackend.

◆ register_port()

PortEngine::PortPtr ARDOUR::PortAudioBackend::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
shortnameName of port to create
typetype of port to create
flagsflags of the port to create
Returns
a reference to the port, otherwise return a null pointer.

Implements ARDOUR::PortEngine.

Definition at line 211 of file portaudio_backend.h.

◆ register_system_audio_ports()

int ARDOUR::PortAudioBackend::register_system_audio_ports ( )
private

◆ register_system_midi_ports()

int ARDOUR::PortAudioBackend::register_system_midi_ports ( std::string const &  device = "")
private

◆ request_input_monitoring()

int ARDOUR::PortAudioBackend::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
portPortHandle
yntrue to enable hardware monitoring, false to disable
Returns
0 on success, -1 otherwise

Implements ARDOUR::PortEngine.

◆ requires_driver_selection()

bool ARDOUR::PortAudioBackend::requires_driver_selection ( ) const
virtual

Return true if this backend requires the selection of a "driver" before any device can be selected. Return false otherwise.

Intended mainly to differentiate between meta-APIs like JACK which can still expose different backends (such as ALSA or CoreAudio or FFADO or netjack) and those like ASIO or CoreAudio which do not.

Reimplemented from ARDOUR::AudioBackend.

◆ reset_device()

int ARDOUR::PortAudioBackend::reset_device ( )
inlinevirtual

Reset device.

Return zero if successful, negative values on error

Implements ARDOUR::AudioBackend.

Definition at line 138 of file portaudio_backend.h.

◆ reset_mmcss()

static bool ARDOUR::PortAudioBackend::reset_mmcss ( HANDLE  task_handle)
staticprivate

◆ running()

bool ARDOUR::PortAudioBackend::running ( )
private

◆ sample_rate()

float ARDOUR::PortAudioBackend::sample_rate ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ sample_time()

samplepos_t ARDOUR::PortAudioBackend::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::PortAudioBackend::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::PortAudioBackend::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::PortAudioBackend::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::PortAudioBackend::set_device_name ( const std::string &  )
virtual

Set the name of the device to be used

Implements ARDOUR::AudioBackend.

◆ set_driver()

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

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 requires_driver_selection()

Reimplemented from ARDOUR::AudioBackend.

◆ set_input_device_name()

int ARDOUR::PortAudioBackend::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::PortAudioBackend::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::PortAudioBackend::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
portPortHandle to operate on
for_playbackWhen 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.
rmin/max latency for given port.

Implements ARDOUR::PortEngine.

◆ set_midi_device_enabled()

int ARDOUR::PortAudioBackend::set_midi_device_enabled ( std::string const  ,
bool   
)
virtual

mark a midi-devices as enabled

Implements ARDOUR::AudioBackend.

◆ set_midi_option()

int ARDOUR::PortAudioBackend::set_midi_option ( const std::string &  )
virtual

Implements ARDOUR::AudioBackend.

◆ set_mmcss_pro_audio()

static bool ARDOUR::PortAudioBackend::set_mmcss_pro_audio ( HANDLE *  task_handle)
staticprivate

◆ set_output_device_name()

int ARDOUR::PortAudioBackend::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_port_name()

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

Set/rename port

Parameters
portPortHandle to operate on
namenew name to use for this port
Returns
zero if successful, non-zero otherwise

Implements ARDOUR::PortEngine.

Definition at line 203 of file portaudio_backend.h.

◆ set_port_property()

int ARDOUR::PortAudioBackend::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
keyThe key of the property.
valueThe value of the property.
typeThe type of the property.
Returns
0 on success, -1 on error

Reimplemented from ARDOUR::PortEngine.

Definition at line 208 of file portaudio_backend.h.

◆ set_sample_rate()

int ARDOUR::PortAudioBackend::set_sample_rate ( float  )
virtual

Set the sample rate to be used

Implements ARDOUR::AudioBackend.

◆ set_systemic_input_latency()

int ARDOUR::PortAudioBackend::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::PortAudioBackend::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::PortAudioBackend::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::PortAudioBackend::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.

◆ set_use_buffered_io()

void ARDOUR::PortAudioBackend::set_use_buffered_io ( bool  )
virtual

Set the backend to use a blocking or buffered I/O mode

Reimplemented from ARDOUR::AudioBackend.

◆ start_blocking_process_thread()

bool ARDOUR::PortAudioBackend::start_blocking_process_thread ( )
private

◆ start_freewheel_process_thread()

bool ARDOUR::PortAudioBackend::start_freewheel_process_thread ( )
private

◆ stop()

int ARDOUR::PortAudioBackend::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_blocking_process_thread()

bool ARDOUR::PortAudioBackend::stop_blocking_process_thread ( )
private

◆ stop_freewheel_process_thread()

bool ARDOUR::PortAudioBackend::stop_freewheel_process_thread ( )
private

◆ systemic_input_latency()

uint32_t ARDOUR::PortAudioBackend::systemic_input_latency ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ systemic_midi_input_latency()

uint32_t ARDOUR::PortAudioBackend::systemic_midi_input_latency ( std::string const  ) const
virtual

Implements ARDOUR::AudioBackend.

◆ systemic_midi_output_latency()

uint32_t ARDOUR::PortAudioBackend::systemic_midi_output_latency ( std::string const  ) const
virtual

Implements ARDOUR::AudioBackend.

◆ systemic_output_latency()

uint32_t ARDOUR::PortAudioBackend::systemic_output_latency ( ) const
virtual

Implements ARDOUR::AudioBackend.

◆ unregister_port()

void ARDOUR::PortAudioBackend::unregister_port ( PortHandle  ph)
inlinevirtual

Reimplemented from ARDOUR::PortEngineSharedImpl.

Definition at line 212 of file portaudio_backend.h.

◆ update_devices()

bool ARDOUR::PortAudioBackend::update_devices ( )
virtual

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.

◆ update_latencies()

void ARDOUR::PortAudioBackend::update_latencies ( )
virtual

Implements ARDOUR::AudioBackend.

◆ update_systemic_midi_latencies()

void ARDOUR::PortAudioBackend::update_systemic_midi_latencies ( )
private

◆ use_separate_input_and_output_devices()

bool ARDOUR::PortAudioBackend::use_separate_input_and_output_devices ( ) const
virtual

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.

Member Data Documentation

◆ _active

bool ARDOUR::PortAudioBackend::_active
private

Definition at line 288 of file portaudio_backend.h.

◆ _cycle_count

uint64_t ARDOUR::PortAudioBackend::_cycle_count
private

Definition at line 304 of file portaudio_backend.h.

◆ _cycle_timer

CycleTimer ARDOUR::PortAudioBackend::_cycle_timer
private

Definition at line 308 of file portaudio_backend.h.

◆ _dsp_calc

ARDOUR::DSPLoadCalculator ARDOUR::PortAudioBackend::_dsp_calc
private

Definition at line 297 of file portaudio_backend.h.

◆ _dsp_load

float ARDOUR::PortAudioBackend::_dsp_load
private

Definition at line 334 of file portaudio_backend.h.

◆ _freewheel

bool ARDOUR::PortAudioBackend::_freewheel
private

Definition at line 290 of file portaudio_backend.h.

◆ _freewheel_ack

bool ARDOUR::PortAudioBackend::_freewheel_ack
private

Definition at line 292 of file portaudio_backend.h.

◆ _freewheel_mutex

pthread_mutex_t ARDOUR::PortAudioBackend::_freewheel_mutex
private

Definition at line 301 of file portaudio_backend.h.

◆ _freewheel_processed

int ARDOUR::PortAudioBackend::_freewheel_processed
private

Definition at line 295 of file portaudio_backend.h.

◆ _freewheel_signal

pthread_cond_t ARDOUR::PortAudioBackend::_freewheel_signal
private

Definition at line 302 of file portaudio_backend.h.

◆ _freewheel_thread_active

bool ARDOUR::PortAudioBackend::_freewheel_thread_active
private

Definition at line 299 of file portaudio_backend.h.

◆ _freewheeling

bool ARDOUR::PortAudioBackend::_freewheeling
private

Definition at line 291 of file portaudio_backend.h.

◆ _input_audio_device

std::string ARDOUR::PortAudioBackend::_input_audio_device
mutableprivate

Definition at line 316 of file portaudio_backend.h.

◆ _input_audio_device_status

std::vector<AudioBackend::DeviceStatus> ARDOUR::PortAudioBackend::_input_audio_device_status
staticprivate

Definition at line 312 of file portaudio_backend.h.

◆ _instance_name

std::string ARDOUR::PortAudioBackend::_instance_name
private

Definition at line 283 of file portaudio_backend.h.

◆ _last_cycle_start

uint64_t ARDOUR::PortAudioBackend::_last_cycle_start
private

Definition at line 309 of file portaudio_backend.h.

◆ _main_blocking_thread

pthread_t ARDOUR::PortAudioBackend::_main_blocking_thread
private

Definition at line 338 of file portaudio_backend.h.

◆ _main_thread

pthread_t ARDOUR::PortAudioBackend::_main_thread
private

Definition at line 341 of file portaudio_backend.h.

◆ _max_buffer_size

size_t ARDOUR::PortAudioBackend::_max_buffer_size
staticprivate

Definition at line 323 of file portaudio_backend.h.

◆ _max_deviation_us

uint64_t ARDOUR::PortAudioBackend::_max_deviation_us
private

Definition at line 306 of file portaudio_backend.h.

◆ _measure_latency

bool ARDOUR::PortAudioBackend::_measure_latency
private

Definition at line 294 of file portaudio_backend.h.

◆ _midi_device_status

std::vector<AudioBackend::DeviceStatus> ARDOUR::PortAudioBackend::_midi_device_status
staticprivate

Definition at line 314 of file portaudio_backend.h.

◆ _midi_driver_option

std::string ARDOUR::PortAudioBackend::_midi_driver_option
private

Definition at line 318 of file portaudio_backend.h.

◆ _midi_options

std::vector<std::string> ARDOUR::PortAudioBackend::_midi_options
staticprivate

Definition at line 311 of file portaudio_backend.h.

◆ _midiio

WinMMEMidiIO* ARDOUR::PortAudioBackend::_midiio
private

Definition at line 285 of file portaudio_backend.h.

◆ _output_audio_device

std::string ARDOUR::PortAudioBackend::_output_audio_device
mutableprivate

Definition at line 317 of file portaudio_backend.h.

◆ _output_audio_device_status

std::vector<AudioBackend::DeviceStatus> ARDOUR::PortAudioBackend::_output_audio_device_status
staticprivate

Definition at line 313 of file portaudio_backend.h.

◆ _pcmio

PortAudioIO* ARDOUR::PortAudioBackend::_pcmio
private

Definition at line 284 of file portaudio_backend.h.

◆ _processed_samples

samplecnt_t ARDOUR::PortAudioBackend::_processed_samples
private

Definition at line 335 of file portaudio_backend.h.

◆ _pthread_freewheel

pthread_t ARDOUR::PortAudioBackend::_pthread_freewheel
private

Definition at line 344 of file portaudio_backend.h.

◆ _reinit_thread_callback

bool ARDOUR::PortAudioBackend::_reinit_thread_callback
private

Definition at line 293 of file portaudio_backend.h.

◆ _run

bool ARDOUR::PortAudioBackend::_run
private

Definition at line 287 of file portaudio_backend.h.

◆ _samplerate

float ARDOUR::PortAudioBackend::_samplerate
private

Definition at line 321 of file portaudio_backend.h.

◆ _samples_per_period

size_t ARDOUR::PortAudioBackend::_samples_per_period
private

Definition at line 322 of file portaudio_backend.h.

◆ _systemic_audio_input_latency

uint32_t ARDOUR::PortAudioBackend::_systemic_audio_input_latency
private

Definition at line 325 of file portaudio_backend.h.

◆ _systemic_audio_output_latency

uint32_t ARDOUR::PortAudioBackend::_systemic_audio_output_latency
private

Definition at line 326 of file portaudio_backend.h.

◆ _threads

std::vector<pthread_t> ARDOUR::PortAudioBackend::_threads
private

Definition at line 348 of file portaudio_backend.h.

◆ _total_deviation_us

uint64_t ARDOUR::PortAudioBackend::_total_deviation_us
private

Definition at line 305 of file portaudio_backend.h.

◆ _use_blocking_api

bool ARDOUR::PortAudioBackend::_use_blocking_api
private

Definition at line 289 of file portaudio_backend.h.


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