2 Copyright (C) 2002 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <glibmm/timer.h>
29 #include "pbd/pthread_utils.h"
30 #include "pbd/stacktrace.h"
31 #include "pbd/unknown_type.h"
34 #include <jack/weakjack.h>
36 #include "midi++/port.h"
37 #include "midi++/mmc.h"
38 #include "midi++/manager.h"
40 #include "ardour/amp.h"
41 #include "ardour/audio_port.h"
42 #include "ardour/audioengine.h"
43 #include "ardour/buffer.h"
44 #include "ardour/buffer_set.h"
45 #include "ardour/cycle_timer.h"
46 #include "ardour/event_type_map.h"
47 #include "ardour/internal_return.h"
48 #include "ardour/internal_send.h"
49 #include "ardour/io.h"
50 #include "ardour/meter.h"
51 #include "ardour/midi_port.h"
52 #include "ardour/process_thread.h"
53 #include "ardour/port.h"
54 #include "ardour/port_set.h"
55 #include "ardour/session.h"
56 #include "ardour/timestamps.h"
57 #include "ardour/utils.h"
62 using namespace ARDOUR;
65 gint AudioEngine::m_meter_exit;
66 AudioEngine* AudioEngine::_instance = 0;
68 #define GET_PRIVATE_JACK_POINTER(j) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
69 #define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
71 AudioEngine::AudioEngine (string client_name, string session_uuid)
74 _instance = this; /* singleton */
76 session_remove_pending = false;
79 last_monitor_check = 0;
80 monitor_check_interval = INT32_MAX;
81 _processed_frames = 0;
86 _freewheeling = false;
87 _pre_freewheel_mmc_enabled = false;
89 port_remove_in_progress = false;
92 g_atomic_int_set (&m_meter_exit, 0);
94 if (connect_to_jack (client_name, session_uuid)) {
95 throw NoBackendAvailable ();
98 Port::set_engine (this);
101 AudioEngine::~AudioEngine ()
104 Glib::Mutex::Lock tm (_process_lock);
105 session_removed.signal ();
108 jack_client_close (_jack);
112 stop_metering_thread ();
117 AudioEngine::jack() const
123 _thread_init_callback (void * /*arg*/)
125 /* make sure that anybody who needs to know about this thread
129 pthread_set_name (X_("audioengine"));
131 PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("Audioengine"), 4096);
132 PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("Audioengine"), 128);
134 SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
136 MIDI::Port::set_process_thread (pthread_self());
140 ardour_jack_error (const char* msg)
142 error << "JACK: " << msg << endmsg;
146 AudioEngine::set_jack_callbacks ()
148 GET_PRIVATE_JACK_POINTER (_jack);
150 if (jack_on_info_shutdown) {
151 jack_on_info_shutdown (_priv_jack, halted_info, this);
153 jack_on_shutdown (_priv_jack, halted, this);
156 jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
157 jack_set_process_thread (_priv_jack, _process_thread, this);
158 jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
159 jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
160 jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
161 jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
162 jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
163 jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
164 jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
165 jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
167 if (_session && _session->config.get_jack_time_master()) {
168 jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
171 #ifdef HAVE_JACK_SESSION
172 if( jack_set_session_callback)
173 jack_set_session_callback (_priv_jack, _session_callback, this);
176 if (jack_set_latency_callback) {
177 jack_set_latency_callback (_priv_jack, _latency_callback, this);
180 jack_set_error_function (ardour_jack_error);
184 AudioEngine::start ()
186 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
190 if (!jack_port_type_get_buffer_size) {
191 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
195 BootMessage (_("Connect session to engine"));
196 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
199 /* a proxy for whether jack_activate() will definitely call the buffer size
200 * callback. with older versions of JACK, this function symbol will be null.
201 * this is reliable, but not clean.
204 if (!jack_port_type_get_buffer_size) {
205 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
208 _processed_frames = 0;
209 last_monitor_check = 0;
211 set_jack_callbacks ();
213 if (jack_activate (_priv_jack) == 0) {
216 Running(); /* EMIT SIGNAL */
218 // error << _("cannot activate JACK client") << endmsg;
222 return _running ? 0 : -1;
226 AudioEngine::stop (bool forever)
228 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
232 disconnect_from_jack ();
234 jack_deactivate (_priv_jack);
235 Stopped(); /* EMIT SIGNAL */
236 MIDI::Port::JackHalted (); /* EMIT SIGNAL */
241 stop_metering_thread ();
244 return _running ? -1 : 0;
249 AudioEngine::get_sync_offset (pframes_t& offset) const
252 #ifdef HAVE_JACK_VIDEO_SUPPORT
254 GET_PRIVATE_JACK_POINTER_RET (_jack, false);
259 (void) jack_transport_query (_priv_jack, &pos);
261 if (pos.valid & JackVideoFrameOffset) {
262 offset = pos.video_offset;
275 AudioEngine::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
276 jack_position_t* pos, int new_position, void *arg)
278 static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
282 AudioEngine::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
283 jack_position_t* pos, int new_position)
285 if (_jack && _session && _session->synced_to_jack()) {
286 _session->jack_timebase_callback (state, nframes, pos, new_position);
291 AudioEngine::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
293 return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
297 AudioEngine::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
299 if (_jack && _session) {
300 return _session->jack_sync_callback (state, pos);
307 AudioEngine::_xrun_callback (void *arg)
309 AudioEngine* ae = static_cast<AudioEngine*> (arg);
310 if (ae->connected()) {
311 ae->Xrun (); /* EMIT SIGNAL */
316 #ifdef HAVE_JACK_SESSION
318 AudioEngine::_session_callback (jack_session_event_t *event, void *arg)
320 AudioEngine* ae = static_cast<AudioEngine*> (arg);
321 if (ae->connected()) {
322 ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
328 AudioEngine::_graph_order_callback (void *arg)
330 AudioEngine* ae = static_cast<AudioEngine*> (arg);
332 if (ae->connected() && !ae->port_remove_in_progress) {
333 ae->GraphReordered (); /* EMIT SIGNAL */
340 AudioEngine::_process_thread (void *arg)
342 return static_cast<AudioEngine *> (arg)->process_thread ();
346 AudioEngine::_freewheel_callback (int onoff, void *arg)
348 static_cast<AudioEngine*>(arg)->freewheel_callback (onoff);
352 AudioEngine::freewheel_callback (int onoff)
354 _freewheeling = onoff;
357 _pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
358 MIDI::Manager::instance()->mmc()->enable_send (false);
360 MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
365 AudioEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
367 AudioEngine* ae = static_cast<AudioEngine*> (arg);
369 if (!ae->port_remove_in_progress) {
370 ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
375 AudioEngine::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
377 return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
381 AudioEngine::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
383 AudioEngine* ae = static_cast<AudioEngine*> (arg);
385 if (ae->port_remove_in_progress) {
389 GET_PRIVATE_JACK_POINTER (ae->_jack);
391 jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
392 jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
394 boost::shared_ptr<Port> port_a;
395 boost::shared_ptr<Port> port_b;
397 boost::shared_ptr<Ports> pr = ae->ports.reader ();
398 Ports::iterator i = pr->begin ();
399 while (i != pr->end() && (port_a == 0 || port_b == 0)) {
400 if (jack_port_a == i->second->jack_port()) {
402 } else if (jack_port_b == i->second->jack_port()) {
408 ae->PortConnectedOrDisconnected (
409 port_a, jack_port_name (jack_port_a),
410 port_b, jack_port_name (jack_port_b),
411 conn == 0 ? false : true
416 AudioEngine::split_cycle (pframes_t offset)
418 /* caller must hold process lock */
420 Port::increment_global_port_buffer_offset (offset);
422 /* tell all Ports that we're going to start a new (split) cycle */
424 boost::shared_ptr<Ports> p = ports.reader();
426 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
427 i->second->cycle_split ();
432 AudioEngine::process_thread ()
434 /* JACK doesn't do this for us when we use the wait API
437 _thread_init_callback (0);
439 _main_thread = new ProcessThread;
442 GET_PRIVATE_JACK_POINTER_RET(_jack,0);
444 pframes_t nframes = jack_cycle_wait (_priv_jack);
446 if (process_callback (nframes)) {
450 jack_cycle_signal (_priv_jack, 0);
456 /** Method called by our ::process_thread when there is work to be done.
457 * @param nframes Number of frames to process.
460 AudioEngine::process_callback (pframes_t nframes)
462 GET_PRIVATE_JACK_POINTER_RET(_jack,0);
463 Glib::Mutex::Lock tm (_process_lock, Glib::TRY_LOCK);
468 /// The number of frames that will have been processed when we've finished
469 pframes_t next_processed_frames;
471 /* handle wrap around of total frames counter */
473 if (max_framepos - _processed_frames < nframes) {
474 next_processed_frames = nframes - (max_framepos - _processed_frames);
476 next_processed_frames = _processed_frames + nframes;
479 if (!tm.locked() || _session == 0) {
480 /* return having done nothing */
481 _processed_frames = next_processed_frames;
485 if (session_remove_pending) {
486 /* perform the actual session removal */
488 session_remove_pending = false;
489 session_removed.signal();
490 _processed_frames = next_processed_frames;
494 /* tell all relevant objects that we're starting a new cycle */
496 InternalSend::CycleStart (nframes);
497 Port::set_global_port_buffer_offset (0);
498 Port::set_cycle_framecnt (nframes);
500 /* tell all Ports that we're starting a new cycle */
502 boost::shared_ptr<Ports> p = ports.reader();
504 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
505 i->second->cycle_start (nframes);
508 /* test if we are freewheeling and there are freewheel signals connected.
509 ardour should act normally even when freewheeling unless /it/ is exporting */
512 if (_freewheeling && !Freewheel.empty()) {
513 /* emit the Freewheel signal and stop freewheeling in the event of trouble
515 boost::optional<int> r = Freewheel (nframes);
516 if (r.get_value_or (0)) {
517 jack_set_freewheel (_priv_jack, false);
522 _session->process (nframes);
531 _processed_frames = next_processed_frames;
535 if (last_monitor_check + monitor_check_interval < next_processed_frames) {
537 boost::shared_ptr<Ports> p = ports.reader();
539 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
543 if (i->second->last_monitor() != (x = i->second->jack_monitoring_input ())) {
544 i->second->set_last_monitor (x);
545 /* XXX I think this is dangerous, due to
546 a likely mutex in the signal handlers ...
548 i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
551 last_monitor_check = next_processed_frames;
554 if (_session->silent()) {
556 boost::shared_ptr<Ports> p = ports.reader();
558 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
560 if (i->second->sends_output()) {
561 i->second->get_buffer(nframes).silence(nframes);
568 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
569 i->second->cycle_end (nframes);
572 _processed_frames = next_processed_frames;
580 AudioEngine::_sample_rate_callback (pframes_t nframes, void *arg)
582 return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
586 AudioEngine::jack_sample_rate_callback (pframes_t nframes)
588 _frame_rate = nframes;
589 _usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
591 /* check for monitor input change every 1/10th of second */
593 monitor_check_interval = nframes / 10;
594 last_monitor_check = 0;
597 _session->set_frame_rate (nframes);
600 SampleRateChanged (nframes); /* EMIT SIGNAL */
606 AudioEngine::jack_latency_callback (jack_latency_callback_mode_t mode)
609 _session->update_latency (mode == JackPlaybackLatency);
614 AudioEngine::_bufsize_callback (pframes_t nframes, void *arg)
616 return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
620 AudioEngine::jack_bufsize_callback (pframes_t nframes)
622 /* if the size has not changed, this should be a no-op */
624 if (nframes == _buffer_size) {
628 GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
630 _buffer_size = nframes;
631 _usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
632 last_monitor_check = 0;
634 if (jack_port_type_get_buffer_size) {
635 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
636 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
639 /* Old version of JACK.
641 These crude guesses, see below where we try to get the right answers.
643 Note that our guess for MIDI deliberatey tries to overestimate
644 by a little. It would be nicer if we could get the actual
645 size from a port, but we have to use this estimate in the
646 event that there are no MIDI ports currently. If there are
647 the value will be adjusted below.
650 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
651 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
655 Glib::Mutex::Lock lm (_process_lock);
657 boost::shared_ptr<Ports> p = ports.reader();
659 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
665 _session->set_block_size (_buffer_size);
672 AudioEngine::stop_metering_thread ()
674 if (m_meter_thread) {
675 g_atomic_int_set (&m_meter_exit, 1);
676 m_meter_thread->join ();
682 AudioEngine::start_metering_thread ()
684 if (m_meter_thread == 0) {
685 g_atomic_int_set (&m_meter_exit, 0);
686 m_meter_thread = Glib::Thread::create (boost::bind (&AudioEngine::meter_thread, this),
687 500000, true, true, Glib::THREAD_PRIORITY_NORMAL);
692 AudioEngine::meter_thread ()
694 pthread_set_name (X_("meter"));
697 Glib::usleep (10000); /* 1/100th sec interval */
698 if (g_atomic_int_get(&m_meter_exit)) {
706 AudioEngine::set_session (Session *s)
708 Glib::Mutex::Lock pl (_process_lock);
710 SessionHandlePtr::set_session (s);
714 start_metering_thread ();
716 pframes_t blocksize = jack_get_buffer_size (_jack);
718 /* page in as much of the session process code as we
719 can before we really start running.
722 boost::shared_ptr<Ports> p = ports.reader();
724 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
725 i->second->cycle_start (blocksize);
728 _session->process (blocksize);
729 _session->process (blocksize);
730 _session->process (blocksize);
731 _session->process (blocksize);
732 _session->process (blocksize);
733 _session->process (blocksize);
734 _session->process (blocksize);
735 _session->process (blocksize);
737 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
738 i->second->cycle_end (blocksize);
744 AudioEngine::remove_session ()
746 Glib::Mutex::Lock lm (_process_lock);
750 stop_metering_thread ();
753 session_remove_pending = true;
754 session_removed.wait(_process_lock);
758 SessionHandlePtr::set_session (0);
765 AudioEngine::port_registration_failure (const std::string& portname)
767 GET_PRIVATE_JACK_POINTER (_jack);
768 string full_portname = jack_client_name;
769 full_portname += ':';
770 full_portname += portname;
773 jack_port_t* p = jack_port_by_name (_priv_jack, full_portname.c_str());
777 reason = string_compose (_("a port with the name \"%1\" already exists: check for duplicated track/bus names"), portname);
779 reason = string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME);
782 throw PortRegistrationFailure (string_compose (_("AudioEngine: cannot register port \"%1\": %2"), portname, reason).c_str());
785 boost::shared_ptr<Port>
786 AudioEngine::register_port (DataType dtype, const string& portname, bool input)
788 boost::shared_ptr<Port> newport;
791 if (dtype == DataType::AUDIO) {
792 newport.reset (new AudioPort (portname, (input ? Port::IsInput : Port::IsOutput)));
793 } else if (dtype == DataType::MIDI) {
794 newport.reset (new MidiPort (portname, (input ? Port::IsInput : Port::IsOutput)));
796 throw PortRegistrationFailure("unable to create port (unknown type)");
799 RCUWriter<Ports> writer (ports);
800 boost::shared_ptr<Ports> ps = writer.get_copy ();
801 ps->insert (make_pair (make_port_name_relative (portname), newport));
803 /* writer goes out of scope, forces update */
808 catch (PortRegistrationFailure& err) {
810 } catch (std::exception& e) {
811 throw PortRegistrationFailure(string_compose(
812 _("unable to create port: %1"), e.what()).c_str());
814 throw PortRegistrationFailure("unable to create port (unknown error)");
818 boost::shared_ptr<Port>
819 AudioEngine::register_input_port (DataType type, const string& portname)
821 return register_port (type, portname, true);
824 boost::shared_ptr<Port>
825 AudioEngine::register_output_port (DataType type, const string& portname)
827 return register_port (type, portname, false);
831 AudioEngine::unregister_port (boost::shared_ptr<Port> port)
833 /* caller must hold process lock */
836 /* probably happening when the engine has been halted by JACK,
837 in which case, there is nothing we can do here.
843 RCUWriter<Ports> writer (ports);
844 boost::shared_ptr<Ports> ps = writer.get_copy ();
845 Ports::iterator x = ps->find (make_port_name_relative (port->name()));
847 if (x != ps->end()) {
851 /* writer goes out of scope, forces update */
860 AudioEngine::connect (const string& source, const string& destination)
866 fatal << _("connect called before engine was started") << endmsg;
873 string s = make_port_name_non_relative (source);
874 string d = make_port_name_non_relative (destination);
877 boost::shared_ptr<Port> src = get_port_by_name (s);
878 boost::shared_ptr<Port> dst = get_port_by_name (d);
881 ret = src->connect (d);
883 ret = dst->connect (s);
885 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
890 /* already exists - no error, no warning */
891 } else if (ret < 0) {
892 error << string_compose(_("AudioEngine: cannot connect %1 (%2) to %3 (%4)"),
893 source, s, destination, d)
901 AudioEngine::disconnect (const string& source, const string& destination)
907 fatal << _("disconnect called before engine was started") << endmsg;
914 string s = make_port_name_non_relative (source);
915 string d = make_port_name_non_relative (destination);
917 boost::shared_ptr<Port> src = get_port_by_name (s);
918 boost::shared_ptr<Port> dst = get_port_by_name (d);
921 ret = src->disconnect (d);
923 ret = dst->disconnect (s);
925 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
932 AudioEngine::disconnect (boost::shared_ptr<Port> port)
934 GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
938 fatal << _("disconnect called before engine was started") << endmsg;
945 return port->disconnect_all ();
949 AudioEngine::frame_rate () const
951 GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
952 if (_frame_rate == 0) {
953 return (_frame_rate = jack_get_sample_rate (_priv_jack));
960 AudioEngine::raw_buffer_size (DataType t)
962 std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
963 return (s != _raw_buffer_sizes.end()) ? s->second : 0;
967 AudioEngine::frames_per_cycle () const
969 GET_PRIVATE_JACK_POINTER_RET (_jack,0);
970 if (_buffer_size == 0) {
971 return jack_get_buffer_size (_jack);
977 /** @param name Full or short name of port
978 * @return Corresponding Port or 0.
981 boost::shared_ptr<Port>
982 AudioEngine::get_port_by_name (const string& portname)
986 fatal << _("get_port_by_name() called before engine was started") << endmsg;
989 boost::shared_ptr<Port> ();
993 if (!port_is_mine (portname)) {
994 /* not an ardour port */
995 return boost::shared_ptr<Port> ();
998 boost::shared_ptr<Ports> pr = ports.reader();
999 std::string rel = make_port_name_relative (portname);
1000 Ports::iterator x = pr->find (rel);
1002 if (x != pr->end()) {
1003 /* its possible that the port was renamed by some 3rd party and
1004 we don't know about it. check for this (the check is quick
1005 and cheap), and if so, rename the port (which will alter
1006 the port map as a side effect).
1008 const std::string check = make_port_name_relative (jack_port_name (x->second->jack_port()));
1010 x->second->set_name (check);
1015 return boost::shared_ptr<Port> ();
1019 AudioEngine::port_renamed (const std::string& old_relative_name, const std::string& new_relative_name)
1021 RCUWriter<Ports> writer (ports);
1022 boost::shared_ptr<Ports> p = writer.get_copy();
1023 Ports::iterator x = p->find (old_relative_name);
1025 if (x != p->end()) {
1026 boost::shared_ptr<Port> port = x->second;
1028 p->insert (make_pair (new_relative_name, port));
1033 AudioEngine::get_ports (const string& port_name_pattern, const string& type_name_pattern, uint32_t flags)
1035 GET_PRIVATE_JACK_POINTER_RET (_jack,0);
1038 fatal << _("get_ports called before engine was started") << endmsg;
1044 return jack_get_ports (_priv_jack, port_name_pattern.c_str(), type_name_pattern.c_str(), flags);
1048 AudioEngine::halted_info (jack_status_t code, const char* reason, void *arg)
1050 /* called from jack shutdown handler */
1052 AudioEngine* ae = static_cast<AudioEngine *> (arg);
1053 bool was_running = ae->_running;
1055 ae->stop_metering_thread ();
1057 ae->_running = false;
1058 ae->_buffer_size = 0;
1059 ae->_frame_rate = 0;
1063 #ifdef HAVE_JACK_ON_INFO_SHUTDOWN
1065 case JackBackendError:
1066 ae->Halted(reason); /* EMIT SIGNAL */
1069 ae->Halted(""); /* EMIT SIGNAL */
1072 ae->Halted(""); /* EMIT SIGNAL */
1078 AudioEngine::halted (void *arg)
1080 cerr << "HALTED by JACK\n";
1082 /* called from jack shutdown handler */
1084 AudioEngine* ae = static_cast<AudioEngine *> (arg);
1085 bool was_running = ae->_running;
1087 ae->stop_metering_thread ();
1089 ae->_running = false;
1090 ae->_buffer_size = 0;
1091 ae->_frame_rate = 0;
1095 ae->Halted(""); /* EMIT SIGNAL */
1096 MIDI::Port::JackHalted (); /* EMIT SIGNAL */
1101 AudioEngine::died ()
1103 /* called from a signal handler for SIGPIPE */
1105 stop_metering_thread ();
1114 AudioEngine::can_request_hardware_monitoring ()
1116 GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1117 const char ** ports;
1119 if ((ports = jack_get_ports (_priv_jack, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortCanMonitor)) == 0) {
1129 AudioEngine::n_physical (unsigned long flags) const
1133 GET_PRIVATE_JACK_POINTER_RET (_jack, c);
1135 const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1140 for (uint32_t i = 0; ports[i]; ++i) {
1141 if (!strstr (ports[i], "Midi-Through")) {
1142 DataType t (jack_port_type (jack_port_by_name (_jack, ports[i])));
1143 c.set (t, c.get (t) + 1);
1153 AudioEngine::n_physical_inputs () const
1155 return n_physical (JackPortIsInput);
1159 AudioEngine::n_physical_outputs () const
1161 return n_physical (JackPortIsOutput);
1165 AudioEngine::get_physical (DataType type, unsigned long flags, vector<string>& phy)
1167 GET_PRIVATE_JACK_POINTER (_jack);
1168 const char ** ports;
1170 if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical | flags)) == 0) {
1175 for (uint32_t i = 0; ports[i]; ++i) {
1176 if (strstr (ports[i], "Midi-Through")) {
1179 phy.push_back (ports[i]);
1185 /** Get physical ports for which JackPortIsOutput is set; ie those that correspond to
1186 * a physical input connector.
1189 AudioEngine::get_physical_inputs (DataType type, vector<string>& ins)
1191 get_physical (type, JackPortIsOutput, ins);
1194 /** Get physical ports for which JackPortIsInput is set; ie those that correspond to
1195 * a physical output connector.
1198 AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
1200 get_physical (type, JackPortIsInput, outs);
1204 AudioEngine::transport_stop ()
1206 GET_PRIVATE_JACK_POINTER (_jack);
1207 jack_transport_stop (_priv_jack);
1211 AudioEngine::transport_start ()
1213 GET_PRIVATE_JACK_POINTER (_jack);
1214 jack_transport_start (_priv_jack);
1218 AudioEngine::transport_locate (framepos_t where)
1220 GET_PRIVATE_JACK_POINTER (_jack);
1221 jack_transport_locate (_priv_jack, where);
1224 AudioEngine::TransportState
1225 AudioEngine::transport_state ()
1227 GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
1228 jack_position_t pos;
1229 return (TransportState) jack_transport_query (_priv_jack, &pos);
1233 AudioEngine::reset_timebase ()
1235 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1237 if (_session->config.get_jack_time_master()) {
1238 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
1240 return jack_release_timebase (_jack);
1247 AudioEngine::freewheel (bool onoff)
1249 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1251 if (onoff != _freewheeling) {
1252 return jack_set_freewheel (_priv_jack, onoff);
1255 /* already doing what has been asked for */
1261 AudioEngine::remove_all_ports ()
1263 /* make sure that JACK callbacks that will be invoked as we cleanup
1264 * ports know that they have nothing to do.
1267 port_remove_in_progress = true;
1269 /* process lock MUST be held by caller
1273 RCUWriter<Ports> writer (ports);
1274 boost::shared_ptr<Ports> ps = writer.get_copy ();
1278 /* clear dead wood list in RCU */
1282 port_remove_in_progress = false;
1286 AudioEngine::connect_to_jack (string client_name, string session_uuid)
1288 EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
1289 boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
1290 jack_options_t options = JackNullOption;
1291 jack_status_t status;
1292 const char *server_name = NULL;
1294 /* revert all environment settings back to whatever they were when ardour started
1298 current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
1299 global_epa->restore ();
1302 jack_client_name = client_name; /* might be reset below */
1303 #ifdef HAVE_JACK_SESSION
1304 if (! session_uuid.empty())
1305 _jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
1308 _jack = jack_client_open (jack_client_name.c_str(), options, &status, server_name);
1310 if (_jack == NULL) {
1311 // error message is not useful here
1315 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1317 if (status & JackNameNotUnique) {
1318 jack_client_name = jack_get_client_name (_priv_jack);
1325 AudioEngine::disconnect_from_jack ()
1327 GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1330 stop_metering_thread ();
1334 Glib::Mutex::Lock lm (_process_lock);
1335 jack_client_close (_priv_jack);
1341 _raw_buffer_sizes.clear();
1345 Stopped(); /* EMIT SIGNAL */
1346 MIDI::Port::JackHalted (); /* EMIT SIGNAL */
1353 AudioEngine::reconnect_to_jack ()
1356 disconnect_from_jack ();
1357 /* XXX give jackd a chance */
1358 Glib::usleep (250000);
1361 if (connect_to_jack (jack_client_name, "")) {
1362 error << _("failed to connect to JACK") << endmsg;
1368 boost::shared_ptr<Ports> p = ports.reader ();
1370 for (i = p->begin(); i != p->end(); ++i) {
1371 if (i->second->reestablish ()) {
1376 if (i != p->end()) {
1378 remove_all_ports ();
1382 GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
1384 MIDI::Manager::instance()->reestablish (_priv_jack);
1387 _session->reset_jack_connection (_priv_jack);
1388 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
1389 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
1392 last_monitor_check = 0;
1394 set_jack_callbacks ();
1396 if (jack_activate (_priv_jack) == 0) {
1403 /* re-establish connections */
1405 for (i = p->begin(); i != p->end(); ++i) {
1406 i->second->reconnect ();
1409 MIDI::Manager::instance()->reconnect ();
1411 Running (); /* EMIT SIGNAL*/
1413 start_metering_thread ();
1419 AudioEngine::request_buffer_size (pframes_t nframes)
1421 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1423 if (nframes == jack_get_buffer_size (_priv_jack)) {
1427 return jack_set_buffer_size (_priv_jack, nframes);
1431 AudioEngine::make_port_name_relative (string portname) const
1433 string::size_type len;
1434 string::size_type n;
1436 len = portname.length();
1438 for (n = 0; n < len; ++n) {
1439 if (portname[n] == ':') {
1444 if ((n != len) && (portname.substr (0, n) == jack_client_name)) {
1445 return portname.substr (n+1);
1452 AudioEngine::make_port_name_non_relative (string portname) const
1456 if (portname.find_first_of (':') != string::npos) {
1460 str = jack_client_name;
1468 AudioEngine::port_is_mine (const string& portname) const
1470 if (portname.find_first_of (':') != string::npos) {
1471 if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
1479 AudioEngine::is_realtime () const
1481 GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1482 return jack_is_realtime (_priv_jack);
1486 AudioEngine::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
1488 GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1489 ThreadData* td = new ThreadData (this, f, stacksize);
1491 if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
1492 jack_is_realtime (_priv_jack), _start_process_thread, td)) {
1500 AudioEngine::_start_process_thread (void* arg)
1502 ThreadData* td = reinterpret_cast<ThreadData*> (arg);
1503 boost::function<void()> f = td->f;
1512 AudioEngine::port_is_physical (const std::string& portname) const
1514 GET_PRIVATE_JACK_POINTER_RET(_jack, false);
1516 jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1522 return jack_port_flags (port) & JackPortIsPhysical;
1526 AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const
1528 GET_PRIVATE_JACK_POINTER(_jack);
1530 jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1536 jack_port_request_monitor (port, yn);
1540 AudioEngine::update_latencies ()
1542 if (jack_recompute_total_latencies) {
1543 GET_PRIVATE_JACK_POINTER (_jack);
1544 jack_recompute_total_latencies (_priv_jack);
1549 AudioEngine::destroy ()