smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-06 14:54:56 +01:00
Code Issues Projects Releases Wiki Activity

inch-like progress on defining the API for AudioBackend and separating AudioEngine from this

Browse source
This commit is contained in:
Paul Davis 2013-07-23 22:14:52 -04:00
parent 8da6a70ead
commit f8ef1e94c3
6 changed files with 819 additions and 760 deletions
Download patch file Download diff file Expand all files Collapse all files

116
libs/ardour/ardour/audioengine.h
View file

@ -69,20 +69,18 @@ public:
AudioEngine (std::string client_name, std::string session_uuid);
virtual ~AudioEngine ();
jack_client_t* jack() const;
bool connected() const { return _jack != 0; }
bool is_realtime () const;
static int discover_backends();
std::vector<std::string> available_backends() const;
ProcessThread* main_thread() const { return _main_thread; }
std::string client_name() const { return jack_client_name; }
int reconnect_to_jack ();
int disconnect_from_jack();
int stop (bool forever = false);
int start ();
int pause ();
int freewheel (bool);
bool running() const { return _running; }
Glib::Threads::Mutex& process_lock() { return _process_lock; }
@ -120,14 +118,6 @@ public:
return jack_last_frame_time (_priv_jack);
}
pframes_t transport_frame () const {
const jack_client_t* _priv_jack = _jack;
if (!_running || !_priv_jack) {
return 0;
}
return jack_get_current_transport_frame (_priv_jack);
}
int request_buffer_size (pframes_t);
framecnt_t processed_frames() const { return _processed_frames; }
@ -143,62 +133,13 @@ public:
void set_session (Session *);
void remove_session (); // not a replacement for SessionHandle::session_going_away()
class PortRegistrationFailure : public std::exception {
public:
PortRegistrationFailure (std::string const & why = "")
: reason (why) {}
~PortRegistrationFailure () throw () {}
virtual const char *what() const throw () { return reason.c_str(); }
private:
std::string reason;
};
class NoBackendAvailable : public std::exception {
public:
virtual const char *what() const throw() { return "could not connect to engine backend"; }
};
boost::shared_ptr<Port> register_input_port (DataType, const std::string& portname);
boost::shared_ptr<Port> register_output_port (DataType, const std::string& portname);
int unregister_port (boost::shared_ptr<Port>);
bool port_is_physical (const std::string&) const;
void request_jack_monitors_input (const std::string&, bool) const;
void split_cycle (pframes_t offset);
int connect (const std::string& source, const std::string& destination);
int disconnect (const std::string& source, const std::string& destination);
int disconnect (boost::shared_ptr<Port>);
const char ** get_ports (const std::string& port_name_pattern, const std::string& type_name_pattern, uint32_t flags);
bool can_request_hardware_monitoring ();
ChanCount n_physical_outputs () const;
ChanCount n_physical_inputs () const;
void get_physical_outputs (DataType type, std::vector<std::string>&);
void get_physical_inputs (DataType type, std::vector<std::string>&);
boost::shared_ptr<Port> get_port_by_name (const std::string &);
void port_renamed (const std::string&, const std::string&);
enum TransportState {
TransportStopped = JackTransportStopped,
TransportRolling = JackTransportRolling,
TransportLooping = JackTransportLooping,
TransportStarting = JackTransportStarting
};
void transport_start ();
void transport_stop ();
void transport_locate (framepos_t);
TransportState transport_state ();
int reset_timebase ();
void update_latencies ();
@ -263,8 +204,6 @@ _ the regular process() call to session->process() is not made.
private:
static AudioEngine* _instance;
jack_client_t* volatile _jack; /* could be reset to null by SIGPIPE or another thread */
std::string jack_client_name;
Glib::Threads::Mutex _process_lock;
Glib::Threads::Cond session_removed;
bool session_remove_pending;
@ -289,6 +228,7 @@ private:
Glib::Threads::Thread* m_meter_thread;
ProcessThread* _main_thread;
SerializedRCUManager<Ports> ports;
boost::shared_ptr<Port> register_port (DataType type, const std::string& portname, bool input);
@ -297,58 +237,14 @@ private:
void* process_thread ();
void remove_all_ports ();
ChanCount n_physical (unsigned long) const;
void get_physical (DataType, unsigned long, std::vector<std::string> &);
void port_registration_failure (const std::string& portname);
static int _xrun_callback (void *arg);
#ifdef HAVE_JACK_SESSION
static void _session_callback (jack_session_event_t *event, void *arg);
#endif
static int _graph_order_callback (void *arg);
static void* _process_thread (void *arg);
static int _sample_rate_callback (pframes_t nframes, void *arg);
static int _bufsize_callback (pframes_t nframes, void *arg);
static void _jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int, void*);
static int _jack_sync_callback (jack_transport_state_t, jack_position_t*, void *arg);
static void _freewheel_callback (int , void *arg);
static void _registration_callback (jack_port_id_t, int, void *);
static void _connect_callback (jack_port_id_t, jack_port_id_t, int, void *);
void jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int);
int jack_sync_callback (jack_transport_state_t, jack_position_t*);
int jack_bufsize_callback (pframes_t);
int jack_sample_rate_callback (pframes_t);
void freewheel_callback (int);
void connect_callback (jack_port_id_t, jack_port_id_t, int);
void set_jack_callbacks ();
static void _latency_callback (jack_latency_callback_mode_t, void*);
void jack_latency_callback (jack_latency_callback_mode_t);
int connect_to_jack (std::string client_name, std::string session_uuid);
static void halted (void *);
static void halted_info (jack_status_t,const char*,void *);
void meter_thread ();
void start_metering_thread ();
void stop_metering_thread ();
static gint m_meter_exit;
struct ThreadData {
AudioEngine* engine;
boost::function<void()> f;
size_t stacksize;
ThreadData (AudioEngine* ae, boost::function<void()> fp, size_t stacksz)
: engine (ae) , f (fp) , stacksize (stacksz) {}
};
static void* _start_process_thread (void*);
void parameter_changed (const std::string&);
PBD::ScopedConnection config_connection;
};

101
libs/ardour/ardour/jack_audiobackend.h Normal file
View file

@ -0,0 +1,101 @@
/*
Copyright (C) 2013 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __ardour_jack_audiobackend_h__
#define __ardour_jack_audiobackend_h__
#include <string>
#include <vector>
#include <stdint.h>
#include "ardour/audio_backend.h"
namespace ARDOUR {
class JACKAudioBackend : public {
public:
JACKAudioBackend (AudioEngine& e);
~JACKAudioBackend ();
std::vector<std::string> enumerate_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;
int set_parameters (const Parameters&);
int get_parameters (Parameters&) const;
int start ();
int stop ();
int pause ();
int freewheel ();
private:
jack_client_t* volatile _jack; /* could be reset to null by SIGPIPE or another thread */
std::string jack_client_name;
static int _xrun_callback (void *arg);
static int _graph_order_callback (void *arg);
static void* _process_thread (void *arg);
static int _sample_rate_callback (pframes_t nframes, void *arg);
static int _bufsize_callback (pframes_t nframes, void *arg);
static void _jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int, void*);
static int _jack_sync_callback (jack_transport_state_t, jack_position_t*, void *arg);
static void _freewheel_callback (int , void *arg);
static void _registration_callback (jack_port_id_t, int, void *);
static void _connect_callback (jack_port_id_t, jack_port_id_t, int, void *);
static void _latency_callback (jack_latency_callback_mode_t, void*);#
static void halted (void *);
static void halted_info (jack_status_t,const char*,void *);
ifdef HAVE_JACK_SESSION
static void _session_callback (jack_session_event_t *event, void *arg);
#endif
void jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int);
int jack_sync_callback (jack_transport_state_t, jack_position_t*);
int jack_bufsize_callback (pframes_t);
int jack_sample_rate_callback (pframes_t);
void freewheel_callback (int);
void connect_callback (jack_port_id_t, jack_port_id_t, int);
int process_callback (pframes_t nframes);
void jack_latency_callback (jack_latency_callback_mode_t);
void set_jack_callbacks ();
int connect_to_jack (std::string client_name, std::string session_uuid);
struct ThreadData {
JACKAudioBackend* engine;
boost::function<void()> f;
size_t stacksize;
ThreadData (JACKAudioBackend* e, boost::function<void()> fp, size_t stacksz)
: engine (e) , f (fp) , stacksize (stacksz) {}
};
void* process_thread ();
static void* _start_process_thread (void*);
ChanCount n_physical (unsigned long) const;
void get_physical (DataType, unsigned long, std::vector<std::string> &);
};
}
#endif /* __ardour_audiobackend_h__ */

50
libs/ardour/ardour/port_manager.h Normal file
View file

@ -0,0 +1,50 @@
namespace ARDOUR
class PortManager
{
public:
PortManager() {}
virtual ~PortManager() {}
/* Port registration */
virtual boost::shared_ptr<Port> register_input_port (DataType, const std::string& portname) = 0;
virtual boost::shared_ptr<Port> register_output_port (DataType, const std::string& portname) = 0;
virtual int unregister_port (boost::shared_ptr<Port>) = 0;
/* Port connectivity */
virtual int connect (const std::string& source, const std::string& destination) = 0;
virtual int disconnect (const std::string& source, const std::string& destination) = 0;
virtual int disconnect (boost::shared_ptr<Port>) = 0;
/* other Port management */
virtual bool port_is_physical (const std::string&) const = 0;
virtual void get_physical_outputs (DataType type, std::vector<std::string>&) = 0;
virtual void get_physical_inputs (DataType type, std::vector<std::string>&) = 0;
virtual boost::shared_ptr<Port> get_port_by_name (const std::string &) = 0;
virtual void port_renamed (const std::string&, const std::string&) = 0;
virtual ChanCount n_physical_outputs () const = 0;
virtual ChanCount n_physical_inputs () const = 0;
virtual const char ** get_ports (const std::string& port_name_pattern, const std::string& type_name_pattern, uint32_t flags) = 0;
/* per-Port monitoring */
virtual bool can_request_input_monitoring () const = 0;
virtual void request_input_monitoring (const std::string&, bool) const = 0;
class PortRegistrationFailure : public std::exception {
public:
PortRegistrationFailure (std::string const & why = "")
: reason (why) {}
~PortRegistrationFailure () throw () {}
virtual const char *what() const throw () { return reason.c_str(); }
private:
std::string reason;
};
};

712
libs/ardour/audioengine.cc
View file

@ -58,17 +58,9 @@ using namespace PBD;
gint AudioEngine::m_meter_exit;
AudioEngine* AudioEngine::_instance = 0;
#define GET_PRIVATE_JACK_POINTER(j) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
#define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
AudioEngine::AudioEngine (string client_name, string session_uuid)
: _jack (0)
, session_remove_pending (false)
AudioEngine::AudioEngine ()
: session_remove_pending (false)
, session_removal_countdown (-1)
, _running (false)
, _has_run (false)
, _buffer_size (0)
, _frame_rate (0)
, monitor_check_interval (INT32_MAX)
, last_monitor_check (0)
, _processed_frames (0)
@ -80,14 +72,8 @@ AudioEngine::AudioEngine (string client_name, string session_uuid)
, _main_thread (0)
, ports (new Ports)
{
_instance = this; /* singleton */
g_atomic_int_set (&m_meter_exit, 0);
if (connect_to_jack (client_name, session_uuid)) {
throw NoBackendAvailable ();
}
Port::set_engine (this);
}
@ -98,16 +84,19 @@ AudioEngine::~AudioEngine ()
{
Glib::Threads::Mutex::Lock tm (_process_lock);
session_removed.signal ();
if (_running) {
jack_client_close (_jack);
_jack = 0;
}
stop_metering_thread ();
}
}
AudioEngine*
AudioEngine::create ()
{
if (_instance) {
return _instance;
}
return new AudioEngine;
}
jack_client_t*
AudioEngine::jack() const
{
@ -131,49 +120,6 @@ _thread_init_callback (void * /*arg*/)
MIDI::JackMIDIPort::set_process_thread (pthread_self());
}
static void
ardour_jack_error (const char* msg)
{
error << "JACK: " << msg << endmsg;
}
void
AudioEngine::set_jack_callbacks ()
{
GET_PRIVATE_JACK_POINTER (_jack);
if (jack_on_info_shutdown) {
jack_on_info_shutdown (_priv_jack, halted_info, this);
} else {
jack_on_shutdown (_priv_jack, halted, this);
}
jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
jack_set_process_thread (_priv_jack, _process_thread, this);
jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
if (_session && _session->config.get_jack_time_master()) {
jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
}
#ifdef HAVE_JACK_SESSION
if( jack_set_session_callback)
jack_set_session_callback (_priv_jack, _session_callback, this);
#endif
if (jack_set_latency_callback) {
jack_set_latency_callback (_priv_jack, _latency_callback, this);
}
jack_set_error_function (ardour_jack_error);
}
int
AudioEngine::start ()
@ -240,180 +186,6 @@ AudioEngine::stop (bool forever)
}
bool
AudioEngine::get_sync_offset (pframes_t& offset) const
{
#ifdef HAVE_JACK_VIDEO_SUPPORT
GET_PRIVATE_JACK_POINTER_RET (_jack, false);
jack_position_t pos;
if (_priv_jack) {
(void) jack_transport_query (_priv_jack, &pos);
if (pos.valid & JackVideoFrameOffset) {
offset = pos.video_offset;
return true;
}
}
#else
/* keep gcc happy */
offset = 0;
#endif
return false;
}
void
AudioEngine::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
jack_position_t* pos, int new_position, void *arg)
{
static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
}
void
AudioEngine::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
jack_position_t* pos, int new_position)
{
if (_jack && _session && _session->synced_to_jack()) {
_session->jack_timebase_callback (state, nframes, pos, new_position);
}
}
int
AudioEngine::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
{
return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
}
int
AudioEngine::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
{
if (_jack && _session) {
return _session->jack_sync_callback (state, pos);
}
return true;
}
int
AudioEngine::_xrun_callback (void *arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (ae->connected()) {
ae->Xrun (); /* EMIT SIGNAL */
}
return 0;
}
#ifdef HAVE_JACK_SESSION
void
AudioEngine::_session_callback (jack_session_event_t *event, void *arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (ae->connected()) {
ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
}
}
#endif
int
AudioEngine::_graph_order_callback (void *arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (ae->connected() && !ae->port_remove_in_progress) {
ae->GraphReordered (); /* EMIT SIGNAL */
}
return 0;
}
void*
AudioEngine::_process_thread (void *arg)
{
return static_cast<AudioEngine *> (arg)->process_thread ();
}
void
AudioEngine::_freewheel_callback (int onoff, void *arg)
{
static_cast<AudioEngine*>(arg)->freewheel_callback (onoff);
}
void
AudioEngine::freewheel_callback (int onoff)
{
_freewheeling = onoff;
if (onoff) {
_pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
MIDI::Manager::instance()->mmc()->enable_send (false);
} else {
MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
}
}
void
AudioEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (!ae->port_remove_in_progress) {
ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
}
}
void
AudioEngine::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
{
return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
}
void
AudioEngine::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
ae->connect_callback (id_a, id_b, conn);
}
void
AudioEngine::connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn)
{
if (port_remove_in_progress) {
return;
}
GET_PRIVATE_JACK_POINTER (_jack);
jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
boost::shared_ptr<Port> port_a;
boost::shared_ptr<Port> port_b;
Ports::iterator x;
boost::shared_ptr<Ports> pr = ports.reader ();
x = pr->find (make_port_name_relative (jack_port_name (jack_port_a)));
if (x != pr->end()) {
port_a = x->second;
}
x = pr->find (make_port_name_relative (jack_port_name (jack_port_b)));
if (x != pr->end()) {
port_b = x->second;
}
PortConnectedOrDisconnected (
port_a, jack_port_name (jack_port_a),
port_b, jack_port_name (jack_port_b),
conn == 0 ? false : true
); /* EMIT SIGNAL */
}
void
AudioEngine::split_cycle (pframes_t offset)
{
@ -430,30 +202,6 @@ AudioEngine::split_cycle (pframes_t offset)
}
}
void*
AudioEngine::process_thread ()
{
/* JACK doesn't do this for us when we use the wait API
*/
_thread_init_callback (0);
_main_thread = new ProcessThread;
while (1) {
GET_PRIVATE_JACK_POINTER_RET(_jack,0);
pframes_t nframes = jack_cycle_wait (_priv_jack);
if (process_callback (nframes)) {
return 0;
}
jack_cycle_signal (_priv_jack, 0);
}
return 0;
}
/** Method called by our ::process_thread when there is work to be done.
* @param nframes Number of frames to process.
@ -644,97 +392,6 @@ AudioEngine::process_callback (pframes_t nframes)
return 0;
}
int
AudioEngine::_sample_rate_callback (pframes_t nframes, void *arg)
{
return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
}
int
AudioEngine::jack_sample_rate_callback (pframes_t nframes)
{
_frame_rate = nframes;
_usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
/* check for monitor input change every 1/10th of second */
monitor_check_interval = nframes / 10;
last_monitor_check = 0;
if (_session) {
_session->set_frame_rate (nframes);
}
SampleRateChanged (nframes); /* EMIT SIGNAL */
return 0;
}
void
AudioEngine::jack_latency_callback (jack_latency_callback_mode_t mode)
{
if (_session) {
_session->update_latency (mode == JackPlaybackLatency);
}
}
int
AudioEngine::_bufsize_callback (pframes_t nframes, void *arg)
{
return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
}
int
AudioEngine::jack_bufsize_callback (pframes_t nframes)
{
/* if the size has not changed, this should be a no-op */
if (nframes == _buffer_size) {
return 0;
}
GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
_buffer_size = nframes;
_usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
last_monitor_check = 0;
if (jack_port_type_get_buffer_size) {
_raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
_raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
} else {
/* Old version of JACK.
These crude guesses, see below where we try to get the right answers.
Note that our guess for MIDI deliberatey tries to overestimate
by a little. It would be nicer if we could get the actual
size from a port, but we have to use this estimate in the
event that there are no MIDI ports currently. If there are
the value will be adjusted below.
*/
_raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
_raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
}
{
Glib::Threads::Mutex::Lock lm (_process_lock);
boost::shared_ptr<Ports> p = ports.reader();
for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
i->second->reset();
}
}
if (_session) {
_session->set_block_size (_buffer_size);
}
return 0;
}
void
AudioEngine::stop_metering_thread ()
@ -759,8 +416,9 @@ void
AudioEngine::meter_thread ()
{
pthread_set_name (X_("meter"));
while (true) {
Glib::usleep (10000);
Glib::usleep (10000); /* 1/100th sec interval */
if (g_atomic_int_get(&m_meter_exit)) {
break;
}
@ -1110,60 +768,6 @@ AudioEngine::get_ports (const string& port_name_pattern, const string& type_name
return jack_get_ports (_priv_jack, port_name_pattern.c_str(), type_name_pattern.c_str(), flags);
}
void
AudioEngine::halted_info (jack_status_t code, const char* reason, void *arg)
{
/* called from jack shutdown handler */
AudioEngine* ae = static_cast<AudioEngine *> (arg);
bool was_running = ae->_running;
ae->stop_metering_thread ();
ae->_running = false;
ae->_buffer_size = 0;
ae->_frame_rate = 0;
ae->_jack = 0;
if (was_running) {
MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
#ifdef HAVE_JACK_ON_INFO_SHUTDOWN
switch (code) {
case JackBackendError:
ae->Halted(reason); /* EMIT SIGNAL */
break;
default:
ae->Halted(""); /* EMIT SIGNAL */
}
#else
ae->Halted(""); /* EMIT SIGNAL */
#endif
}
}
void
AudioEngine::halted (void *arg)
{
cerr << "HALTED by JACK\n";
/* called from jack shutdown handler */
AudioEngine* ae = static_cast<AudioEngine *> (arg);
bool was_running = ae->_running;
ae->stop_metering_thread ();
ae->_running = false;
ae->_buffer_size = 0;
ae->_frame_rate = 0;
ae->_jack = 0;
if (was_running) {
MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
ae->Halted(""); /* EMIT SIGNAL */
}
}
void
AudioEngine::died ()
{
@ -1267,34 +871,6 @@ AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
get_physical (type, JackPortIsInput, outs);
}
void
AudioEngine::transport_stop ()
{
GET_PRIVATE_JACK_POINTER (_jack);
jack_transport_stop (_priv_jack);
}
void
AudioEngine::transport_start ()
{
GET_PRIVATE_JACK_POINTER (_jack);
jack_transport_start (_priv_jack);
}
void
AudioEngine::transport_locate (framepos_t where)
{
GET_PRIVATE_JACK_POINTER (_jack);
jack_transport_locate (_priv_jack, where);
}
AudioEngine::TransportState
AudioEngine::transport_state ()
{
GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
jack_position_t pos;
return (TransportState) jack_transport_query (_priv_jack, &pos);
}
int
AudioEngine::reset_timebase ()
@ -1310,20 +886,6 @@ AudioEngine::reset_timebase ()
return 0;
}
int
AudioEngine::freewheel (bool onoff)
{
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
if (onoff != _freewheeling) {
return jack_set_freewheel (_priv_jack, onoff);
} else {
/* already doing what has been asked for */
return 0;
}
}
void
AudioEngine::remove_all_ports ()
{
@ -1349,148 +911,6 @@ AudioEngine::remove_all_ports ()
port_remove_in_progress = false;
}
int
AudioEngine::connect_to_jack (string client_name, string session_uuid)
{
EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
jack_status_t status;
/* revert all environment settings back to whatever they were when ardour started
*/
if (global_epa) {
current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
global_epa->restore ();
}
jack_client_name = client_name; /* might be reset below */
#ifdef HAVE_JACK_SESSION
if (! session_uuid.empty())
_jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
else
#endif
_jack = jack_client_open (jack_client_name.c_str(), JackNullOption, &status, 0);
if (_jack == NULL) {
// error message is not useful here
return -1;
}
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
if (status & JackNameNotUnique) {
jack_client_name = jack_get_client_name (_priv_jack);
}
return 0;
}
int
AudioEngine::disconnect_from_jack ()
{
GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
if (_running) {
stop_metering_thread ();
}
{
Glib::Threads::Mutex::Lock lm (_process_lock);
jack_client_close (_priv_jack);
_jack = 0;
}
_buffer_size = 0;
_frame_rate = 0;
_raw_buffer_sizes.clear();
if (_running) {
_running = false;
MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
Stopped(); /* EMIT SIGNAL */
}
return 0;
}
int
AudioEngine::reconnect_to_jack ()
{
if (_running) {
disconnect_from_jack ();
/* XXX give jackd a chance */
Glib::usleep (250000);
}
if (connect_to_jack (jack_client_name, "")) {
error << _("failed to connect to JACK") << endmsg;
return -1;
}
Ports::iterator i;
boost::shared_ptr<Ports> p = ports.reader ();
for (i = p->begin(); i != p->end(); ++i) {
if (i->second->reestablish ()) {
break;
}
}
if (i != p->end()) {
/* failed */
remove_all_ports ();
return -1;
}
GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
MIDI::Manager::instance()->reestablish (_priv_jack);
if (_session) {
_session->reset_jack_connection (_priv_jack);
jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
_session->set_frame_rate (jack_get_sample_rate (_priv_jack));
}
last_monitor_check = 0;
set_jack_callbacks ();
if (jack_activate (_priv_jack) == 0) {
_running = true;
_has_run = true;
} else {
return -1;
}
/* re-establish connections */
for (i = p->begin(); i != p->end(); ++i) {
i->second->reconnect ();
}
MIDI::Manager::instance()->reconnect ();
Running (); /* EMIT SIGNAL*/
start_metering_thread ();
return 0;
}
int
AudioEngine::request_buffer_size (pframes_t nframes)
{
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
if (nframes == jack_get_buffer_size (_priv_jack)) {
return 0;
}
return jack_set_buffer_size (_priv_jack, nframes);
}
string
AudioEngine::make_port_name_relative (string portname) const
@ -1540,39 +960,6 @@ AudioEngine::port_is_mine (const string& portname) const
return true;
}
bool
AudioEngine::is_realtime () const
{
GET_PRIVATE_JACK_POINTER_RET (_jack,false);
return jack_is_realtime (_priv_jack);
}
int
AudioEngine::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
{
GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
ThreadData* td = new ThreadData (this, f, stacksize);
if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
jack_is_realtime (_priv_jack), _start_process_thread, td)) {
return -1;
}
return 0;
}
void*
AudioEngine::_start_process_thread (void* arg)
{
ThreadData* td = reinterpret_cast<ThreadData*> (arg);
boost::function<void()> f = td->f;
delete td;
f ();
return 0;
}
bool
AudioEngine::port_is_physical (const std::string& portname) const
{
@ -1587,29 +974,6 @@ AudioEngine::port_is_physical (const std::string& portname) const
return jack_port_flags (port) & JackPortIsPhysical;
}
void
AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const
{
GET_PRIVATE_JACK_POINTER(_jack);
jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
if (!port) {
return;
}
jack_port_request_monitor (port, yn);
}
void
AudioEngine::update_latencies ()
{
if (jack_recompute_total_latencies) {
GET_PRIVATE_JACK_POINTER (_jack);
jack_recompute_total_latencies (_priv_jack);
}
}
void
AudioEngine::destroy ()
{
@ -1617,3 +981,53 @@ AudioEngine::destroy ()
_instance = 0;
}
int
AudioEngine::discover_backends ()
{
vector<std::string> backend_modules;
AudioBackend* backend;
Glib::PatternSpec so_extension_pattern("*.so");
Glib::PatternSpec dylib_extension_pattern("*.dylib");
find_matching_files_in_search_path (backend_search_path (),
so_extension_pattern, backend_modules);
find_matching_files_in_search_path (backend_search_path (),
dylib_extension_pattern, backend_modules);
DEBUG_TRACE (DEBUG::Panning, string_compose (_("looking for backends in %1"), backend_search_path().to_string()));
for (vector<std::string>::iterator i = backend_modules.begin(); i != backend_modules.end(); ++i) {
if ((backend = backend_discover (*i)) != 0) {
_backends.insert (make_pair (backend->name(), backend));
}
}
}
AudioBackend*
AudioEngine::backend_discover (string path)
{
Glib::Module* module = new Glib::Module(path);
AudioBackend* (*dfunc)(void);
void* func = 0;
if (!module) {
error << string_compose(_("AudioEngine: cannot load module \"%1\" (%2)"), path,
Glib::Module::get_last_error()) << endmsg;
delete module;
return 0;
}
if (!module->get_symbol("backend_factory", func)) {
error << string_compose(_("AudioEngine: module \"%1\" has no factory function."), path) << endmsg;
error << Glib::Module::get_last_error() << endmsg;
delete module;
return 0;
}
dfunc = (AudioBackend* (*)(void))func;
AudioBackend* backend = dfunc();
return backend;
}

597
libs/ardour/jack_audiobackend.cc Normal file
View file

@ -0,0 +1,597 @@
#include "ardour/jack_audiobackend.h"
#define GET_PRIVATE_JACK_POINTER(j) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
#define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
int
JACKAudioBackend::start ()
{
Glib::Threads::Mutex::Lock lm (_state_lock);
if (running()) {
/* already running */
return 1;
}
}
int
JACKAudioBackend::stop ()
{
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
{
Glib::Threads::Mutex::Lock lm (_process_lock);
jack_client_close (_priv_jack);
_jack = 0;
}
_buffer_size = 0;
_frame_rate = 0;
_raw_buffer_sizes.clear();
return 0;
}
int
JACKAudioBackend::pause ()
{
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
if (_priv_jack) {
jack_deactivate (_priv_jack);
}
return 0;
}
int
JACKAudioBackend::freewheel (bool onoff)
{
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
if (onoff == _freewheeling) {
/* already doing what has been asked for */
return 0;
}
return jack_set_freewheel (_priv_jack, onoff);
}
int
JACKAudioBackend::set_parameters (const Parameters& params)
{
return 0;
}
int
JACKAudioBackend::get_parameters (Parameters& params) const
{
return 0;
}
/*--- private support methods ---*/
int
JACKAudioBackend::connect_to_jack (string client_name, string session_uuid)
{
EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
jack_status_t status;
/* revert all environment settings back to whatever they were when ardour started
*/
if (global_epa) {
current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
global_epa->restore ();
}
jack_client_name = client_name; /* might be reset below */
#ifdef HAVE_JACK_SESSION
if (!session_uuid.empty())
_jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
else
#endif
_jack = jack_client_open (jack_client_name.c_str(), JackNullOption, &status, 0);
if (_jack == NULL) {
// error message is not useful here
return -1;
}
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
if (status & JackNameNotUnique) {
jack_client_name = jack_get_client_name (_priv_jack);
}
return 0;
}
int
JACKAudioBackend::disconnect_from_jack ()
{
int
AudioEngine::reconnect_to_jack ()
{
if (_running) {
disconnect_from_jack ();
/* XXX give jackd a chance */
Glib::usleep (250000);
}
if (connect_to_jack (jack_client_name, "")) {
error << _("failed to connect to JACK") << endmsg;
return -1;
}
Ports::iterator i;
boost::shared_ptr<Ports> p = ports.reader ();
for (i = p->begin(); i != p->end(); ++i) {
if (i->second->reestablish ()) {
break;
}
}
if (i != p->end()) {
/* failed */
remove_all_ports ();
return -1;
}
GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
MIDI::Manager::instance()->reestablish (_priv_jack);
if (_session) {
_session->reset_jack_connection (_priv_jack);
jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
_session->set_frame_rate (jack_get_sample_rate (_priv_jack));
}
last_monitor_check = 0;
set_jack_callbacks ();
if (jack_activate (_priv_jack) == 0) {
_running = true;
_has_run = true;
} else {
return -1;
}
/* re-establish connections */
for (i = p->begin(); i != p->end(); ++i) {
i->second->reconnect ();
}
MIDI::Manager::instance()->reconnect ();
Running (); /* EMIT SIGNAL*/
start_metering_thread ();
return 0;
}
int
JACKAudioBackend::request_buffer_size (pframes_t nframes)
{
GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
if (nframes == jack_get_buffer_size (_priv_jack)) {
return 0;
}
return jack_set_buffer_size (_priv_jack, nframes);
}
/* --- TRANSPORT STATE MANAGEMENT --- */
void
AudioEngine::transport_stop ()
{
GET_PRIVATE_JACK_POINTER (_jack);
jack_transport_stop (_priv_jack);
}
void
AudioEngine::transport_start ()
{
GET_PRIVATE_JACK_POINTER (_jack);
jack_transport_start (_priv_jack);
}
void
AudioEngine::transport_locate (framepos_t where)
{
GET_PRIVATE_JACK_POINTER (_jack);
jack_transport_locate (_priv_jack, where);
}
framepos_t
AudioEngine::transport_frame () const
{
GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
return jack_get_current_transport_frame (_priv_jack);
}
AudioEngine::TransportState
AudioEngine::transport_state ()
{
GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
jack_position_t pos;
return (TransportState) jack_transport_query (_priv_jack, &pos);
}
/* JACK Callbacks */
static void
ardour_jack_error (const char* msg)
{
error << "JACK: " << msg << endmsg;
}
void
JACKAudioBackend::set_jack_callbacks ()
{
GET_PRIVATE_JACK_POINTER (_jack);
if (jack_on_info_shutdown) {
jack_on_info_shutdown (_priv_jack, halted_info, this);
} else {
jack_on_shutdown (_priv_jack, halted, this);
}
jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
jack_set_process_thread (_priv_jack, _process_thread, this);
jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
if (_session && _session->config.get_jack_time_master()) {
jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
}
#ifdef HAVE_JACK_SESSION
if( jack_set_session_callback)
jack_set_session_callback (_priv_jack, _session_callback, this);
#endif
if (jack_set_latency_callback) {
jack_set_latency_callback (_priv_jack, _latency_callback, this);
}
jack_set_error_function (ardour_jack_error);
}
void
JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
jack_position_t* pos, int new_position, void *arg)
{
static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
}
void
JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
jack_position_t* pos, int new_position)
{
if (_jack && _session && _session->synced_to_jack()) {
_session->jack_timebase_callback (state, nframes, pos, new_position);
}
}
int
JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
{
return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
}
int
JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
{
if (_jack && _session) {
return _session->jack_sync_callback (state, pos);
}
return true;
}
int
JACKAudioBackend::_xrun_callback (void *arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (ae->connected()) {
ae->Xrun (); /* EMIT SIGNAL */
}
return 0;
}
#ifdef HAVE_JACK_SESSION
void
JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (ae->connected()) {
ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
}
}
#endif
int
JACKAudioBackend::_graph_order_callback (void *arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (ae->connected() && !ae->port_remove_in_progress) {
ae->GraphReordered (); /* EMIT SIGNAL */
}
return 0;
}
void
JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
{
static_cast<AudioEngine*>(arg)->freewheel_callback (onoff);
}
void
JACKAudioBackend::freewheel_callback (int onoff)
{
_freewheeling = onoff;
if (onoff) {
_pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
MIDI::Manager::instance()->mmc()->enable_send (false);
} else {
MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
}
}
void
JACKAudioBackend::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
if (!ae->port_remove_in_progress) {
ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
}
}
void
JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
{
return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
}
void
JACKAudioBackend::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
{
AudioEngine* ae = static_cast<AudioEngine*> (arg);
ae->connect_callback (id_a, id_b, conn);
}
void
JACKAudioBackend::connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn)
{
if (port_remove_in_progress) {
return;
}
GET_PRIVATE_JACK_POINTER (_jack);
jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
boost::shared_ptr<Port> port_a;
boost::shared_ptr<Port> port_b;
Ports::iterator x;
boost::shared_ptr<Ports> pr = ports.reader ();
x = pr->find (make_port_name_relative (jack_port_name (jack_port_a)));
if (x != pr->end()) {
port_a = x->second;
}
x = pr->find (make_port_name_relative (jack_port_name (jack_port_b)));
if (x != pr->end()) {
port_b = x->second;
}
PortConnectedOrDisconnected (
port_a, jack_port_name (jack_port_a),
port_b, jack_port_name (jack_port_b),
conn == 0 ? false : true
); /* EMIT SIGNAL */
}
void*
JACKAudioBackend::_process_thread (void *arg)
{
return static_cast<AudioEngine *> (arg)->process_thread ();
}
void*
JACKAudioBackend::process_thread ()
{
/* JACK doesn't do this for us when we use the wait API
*/
_thread_init_callback (0);
_main_thread = new ProcessThread;
while (1) {
GET_PRIVATE_JACK_POINTER_RET(_jack,0);
pframes_t nframes = jack_cycle_wait (_priv_jack);
if (process_callback (nframes)) {
return 0;
}
jack_cycle_signal (_priv_jack, 0);
}
return 0;
}
int
JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
{
return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
}
int
JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
{
_frame_rate = nframes;
_usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
/* check for monitor input change every 1/10th of second */
monitor_check_interval = nframes / 10;
last_monitor_check = 0;
if (_session) {
_session->set_frame_rate (nframes);
}
SampleRateChanged (nframes); /* EMIT SIGNAL */
return 0;
}
void
JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
{
if (_session) {
_session->update_latency (mode == JackPlaybackLatency);
}
}
int
JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
{
return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
}
int
JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
{
/* if the size has not changed, this should be a no-op */
if (nframes == _buffer_size) {
return 0;
}
GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
_buffer_size = nframes;
_usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
last_monitor_check = 0;
if (jack_port_type_get_buffer_size) {
_raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
_raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
} else {
/* Old version of JACK.
These crude guesses, see below where we try to get the right answers.
Note that our guess for MIDI deliberatey tries to overestimate
by a little. It would be nicer if we could get the actual
size from a port, but we have to use this estimate in the
event that there are no MIDI ports currently. If there are
the value will be adjusted below.
*/
_raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
_raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
}
{
Glib::Threads::Mutex::Lock lm (_process_lock);
boost::shared_ptr<Ports> p = ports.reader();
for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
i->second->reset();
}
}
if (_session) {
_session->set_block_size (_buffer_size);
}
return 0;
}
void
JACKAudioBackend::halted_info (jack_status_t code, const char* reason, void *arg)
{
/* called from jack shutdown handler */
AudioEngine* ae = static_cast<AudioEngine *> (arg);
bool was_running = ae->_running;
ae->stop_metering_thread ();
ae->_running = false;
ae->_buffer_size = 0;
ae->_frame_rate = 0;
ae->_jack = 0;
if (was_running) {
MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
#ifdef HAVE_JACK_ON_INFO_SHUTDOWN
switch (code) {
case JackBackendError:
ae->Halted(reason); /* EMIT SIGNAL */
break;
default:
ae->Halted(""); /* EMIT SIGNAL */
}
#else
ae->Halted(""); /* EMIT SIGNAL */
#endif
}
}
void
JACKAudioBackend::halted (void *arg)
{
cerr << "HALTED by JACK\n";
/* called from jack shutdown handler */
AudioEngine* ae = static_cast<AudioEngine *> (arg);
bool was_running = ae->_running;
ae->stop_metering_thread ();
ae->_running = false;
ae->_buffer_size = 0;
ae->_frame_rate = 0;
ae->_jack = 0;
if (was_running) {
MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
ae->Halted(""); /* EMIT SIGNAL */
}
}

1
libs/ardour/panner_manager.cc
View file

@ -79,6 +79,7 @@ PannerManager::discover_panners ()
panner_discover (*i);
}
}
int
PannerManager::panner_discover (string path)
{