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; }
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; }
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 ();
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;
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);
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;
};
--- /dev/null
+/*
+ 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__ */
+
--- /dev/null
+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;
+ };
+
+};
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)
, _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);
}
{
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
{
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 ()
}
-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)
{
}
}
-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.
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 ()
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;
}
ARDOUR::pframes_t
AudioEngine::frames_per_cycle () const
{
- GET_PRIVATE_JACK_POINTER_RET (_jack,0);
+ GET_PRIVATE_JACK_POINTER_RET (_jack,0);
if (_buffer_size == 0) {
return jack_get_buffer_size (_jack);
} else {
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 ()
{
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 ()
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 ()
{
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
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
{
}
void
-AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const
+AudioEngine::destroy ()
{
- GET_PRIVATE_JACK_POINTER(_jack);
+ delete _instance;
+ _instance = 0;
+}
- jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
+int
+AudioEngine::discover_backends ()
+{
+ vector<std::string> backend_modules;
+ AudioBackend* backend;
- if (!port) {
- return;
- }
+ Glib::PatternSpec so_extension_pattern("*.so");
+ Glib::PatternSpec dylib_extension_pattern("*.dylib");
- jack_port_request_monitor (port, yn);
-}
+ find_matching_files_in_search_path (backend_search_path (),
+ so_extension_pattern, backend_modules);
-void
-AudioEngine::update_latencies ()
-{
- if (jack_recompute_total_latencies) {
- GET_PRIVATE_JACK_POINTER (_jack);
- jack_recompute_total_latencies (_priv_jack);
- }
+ 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));
+ }
+ }
}
-void
-AudioEngine::destroy ()
+AudioBackend*
+AudioEngine::backend_discover (string path)
{
- delete _instance;
- _instance = 0;
-}
+ 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;
+}
--- /dev/null
+#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 */
+ }
+}
+
panner_discover (*i);
}
}
+
int
PannerManager::panner_discover (string path)
{
projects / ardour.git / commitdiff