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 "midi++/port.h"
35 #include "midi++/jack_midi_port.h"
36 #include "midi++/mmc.h"
37 #include "midi++/manager.h"
39 #include "ardour/audio_port.h"
40 #include "ardour/audioengine.h"
41 #include "ardour/buffer.h"
42 #include "ardour/cycle_timer.h"
43 #include "ardour/internal_send.h"
44 #include "ardour/meter.h"
45 #include "ardour/midi_port.h"
46 #include "ardour/port.h"
47 #include "ardour/process_thread.h"
48 #include "ardour/session.h"
53 using namespace ARDOUR;
56 gint AudioEngine::m_meter_exit;
57 AudioEngine* AudioEngine::_instance = 0;
59 #define GET_PRIVATE_JACK_POINTER(j) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
60 #define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
62 AudioEngine::AudioEngine (string client_name, string session_uuid)
64 , session_remove_pending (false)
65 , session_removal_countdown (-1)
70 , monitor_check_interval (INT32_MAX)
71 , last_monitor_check (0)
72 , _processed_frames (0)
73 , _freewheeling (false)
74 , _pre_freewheel_mmc_enabled (false)
75 , _usecs_per_cycle (0)
76 , port_remove_in_progress (false)
81 _instance = this; /* singleton */
83 g_atomic_int_set (&m_meter_exit, 0);
85 if (connect_to_jack (client_name, session_uuid)) {
86 throw NoBackendAvailable ();
89 Port::set_engine (this);
92 AudioEngine::~AudioEngine ()
94 config_connection.disconnect ();
97 Glib::Threads::Mutex::Lock tm (_process_lock);
98 session_removed.signal ();
101 jack_client_close (_jack);
105 stop_metering_thread ();
110 AudioEngine::jack() const
116 _thread_init_callback (void * /*arg*/)
118 /* make sure that anybody who needs to know about this thread
122 pthread_set_name (X_("audioengine"));
124 PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("Audioengine"), 4096);
125 PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("Audioengine"), 128);
127 SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
129 MIDI::JackMIDIPort::set_process_thread (pthread_self());
133 ardour_jack_error (const char* msg)
135 error << "JACK: " << msg << endmsg;
139 AudioEngine::set_jack_callbacks ()
141 GET_PRIVATE_JACK_POINTER (_jack);
143 if (jack_on_info_shutdown) {
144 jack_on_info_shutdown (_priv_jack, halted_info, this);
146 jack_on_shutdown (_priv_jack, halted, this);
149 jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
150 jack_set_process_thread (_priv_jack, _process_thread, this);
151 jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
152 jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
153 jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
154 jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
155 jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
156 jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
157 jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
158 jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
160 if (_session && _session->config.get_jack_time_master()) {
161 jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
164 #ifdef HAVE_JACK_SESSION
165 if( jack_set_session_callback)
166 jack_set_session_callback (_priv_jack, _session_callback, this);
169 if (jack_set_latency_callback) {
170 jack_set_latency_callback (_priv_jack, _latency_callback, this);
173 jack_set_error_function (ardour_jack_error);
177 AudioEngine::start ()
179 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
183 if (!jack_port_type_get_buffer_size) {
184 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
188 BootMessage (_("Connect session to engine"));
189 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
192 /* a proxy for whether jack_activate() will definitely call the buffer size
193 * callback. with older versions of JACK, this function symbol will be null.
194 * this is reliable, but not clean.
197 if (!jack_port_type_get_buffer_size) {
198 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
201 _processed_frames = 0;
202 last_monitor_check = 0;
204 set_jack_callbacks ();
206 if (jack_activate (_priv_jack) == 0) {
209 Running(); /* EMIT SIGNAL */
211 // error << _("cannot activate JACK client") << endmsg;
215 return _running ? 0 : -1;
219 AudioEngine::stop (bool forever)
221 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
225 disconnect_from_jack ();
227 jack_deactivate (_priv_jack);
228 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
229 Stopped(); /* EMIT SIGNAL */
234 stop_metering_thread ();
237 return _running ? -1 : 0;
242 AudioEngine::get_sync_offset (pframes_t& offset) const
245 #ifdef HAVE_JACK_VIDEO_SUPPORT
247 GET_PRIVATE_JACK_POINTER_RET (_jack, false);
252 (void) jack_transport_query (_priv_jack, &pos);
254 if (pos.valid & JackVideoFrameOffset) {
255 offset = pos.video_offset;
268 AudioEngine::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
269 jack_position_t* pos, int new_position, void *arg)
271 static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
275 AudioEngine::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
276 jack_position_t* pos, int new_position)
278 if (_jack && _session && _session->synced_to_jack()) {
279 _session->jack_timebase_callback (state, nframes, pos, new_position);
284 AudioEngine::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
286 return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
290 AudioEngine::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
292 if (_jack && _session) {
293 return _session->jack_sync_callback (state, pos);
300 AudioEngine::_xrun_callback (void *arg)
302 AudioEngine* ae = static_cast<AudioEngine*> (arg);
303 if (ae->connected()) {
304 ae->Xrun (); /* EMIT SIGNAL */
309 #ifdef HAVE_JACK_SESSION
311 AudioEngine::_session_callback (jack_session_event_t *event, void *arg)
313 AudioEngine* ae = static_cast<AudioEngine*> (arg);
314 if (ae->connected()) {
315 ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
321 AudioEngine::_graph_order_callback (void *arg)
323 AudioEngine* ae = static_cast<AudioEngine*> (arg);
325 if (ae->connected() && !ae->port_remove_in_progress) {
326 ae->GraphReordered (); /* EMIT SIGNAL */
333 AudioEngine::_process_thread (void *arg)
335 return static_cast<AudioEngine *> (arg)->process_thread ();
339 AudioEngine::_freewheel_callback (int onoff, void *arg)
341 static_cast<AudioEngine*>(arg)->freewheel_callback (onoff);
345 AudioEngine::freewheel_callback (int onoff)
347 _freewheeling = onoff;
350 _pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
351 MIDI::Manager::instance()->mmc()->enable_send (false);
353 MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
358 AudioEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
360 AudioEngine* ae = static_cast<AudioEngine*> (arg);
362 if (!ae->port_remove_in_progress) {
363 ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
368 AudioEngine::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
370 return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
374 AudioEngine::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
376 AudioEngine* ae = static_cast<AudioEngine*> (arg);
377 ae->connect_callback (id_a, id_b, conn);
381 AudioEngine::connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn)
383 if (port_remove_in_progress) {
387 GET_PRIVATE_JACK_POINTER (_jack);
389 jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
390 jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
392 boost::shared_ptr<Port> port_a;
393 boost::shared_ptr<Port> port_b;
395 boost::shared_ptr<Ports> pr = ports.reader ();
398 x = pr->find (make_port_name_relative (jack_port_name (jack_port_a)));
399 if (x != pr->end()) {
403 x = pr->find (make_port_name_relative (jack_port_name (jack_port_b)));
404 if (x != pr->end()) {
408 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::Threads::Mutex::Lock tm (_process_lock, Glib::Threads::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;
480 /* return having done nothing */
481 _processed_frames = next_processed_frames;
485 if (session_remove_pending) {
487 /* perform the actual session removal */
489 if (session_removal_countdown < 0) {
491 /* fade out over 1 second */
492 session_removal_countdown = _frame_rate/2;
493 session_removal_gain = 1.0;
494 session_removal_gain_step = 1.0/session_removal_countdown;
496 } else if (session_removal_countdown > 0) {
498 /* we'll be fading audio out.
500 if this is the last time we do this as part
501 of session removal, do a MIDI panic now
502 to get MIDI stopped. This relies on the fact
503 that "immediate data" (aka "out of band data") from
504 MIDI tracks is *appended* after any other data,
505 so that it emerges after any outbound note ons, etc.
508 if (session_removal_countdown <= nframes) {
509 _session->midi_panic ();
515 session_removal_countdown = -1; // reset to "not in progress"
516 session_remove_pending = false;
517 session_removed.signal(); // wakes up thread that initiated session removal
523 if (!_freewheeling) {
524 MIDI::Manager::instance()->cycle_start(nframes);
525 MIDI::Manager::instance()->cycle_end();
528 _processed_frames = next_processed_frames;
533 /* tell all relevant objects that we're starting a new cycle */
535 InternalSend::CycleStart (nframes);
536 Port::set_global_port_buffer_offset (0);
537 Port::set_cycle_framecnt (nframes);
539 /* tell all Ports that we're starting a new cycle */
541 boost::shared_ptr<Ports> p = ports.reader();
543 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
544 i->second->cycle_start (nframes);
547 /* test if we are freewheeling and there are freewheel signals connected.
548 ardour should act normally even when freewheeling unless /it/ is
552 if (_freewheeling && !Freewheel.empty()) {
557 MIDI::Manager::instance()->cycle_start(nframes);
560 _session->process (nframes);
563 MIDI::Manager::instance()->cycle_end();
571 _processed_frames = next_processed_frames;
575 if (last_monitor_check + monitor_check_interval < next_processed_frames) {
577 boost::shared_ptr<Ports> p = ports.reader();
579 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
583 if (i->second->last_monitor() != (x = i->second->jack_monitoring_input ())) {
584 i->second->set_last_monitor (x);
585 /* XXX I think this is dangerous, due to
586 a likely mutex in the signal handlers ...
588 i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
591 last_monitor_check = next_processed_frames;
594 if (_session->silent()) {
596 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
598 if (i->second->sends_output()) {
599 i->second->get_buffer(nframes).silence(nframes);
604 if (session_remove_pending && session_removal_countdown) {
606 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
608 if (i->second->sends_output()) {
610 boost::shared_ptr<AudioPort> ap = boost::dynamic_pointer_cast<AudioPort> (i->second);
612 Sample* s = ap->engine_get_whole_audio_buffer ();
613 gain_t g = session_removal_gain;
615 for (pframes_t n = 0; n < nframes; ++n) {
617 g -= session_removal_gain_step;
623 if (session_removal_countdown > nframes) {
624 session_removal_countdown -= nframes;
626 session_removal_countdown = 0;
629 session_removal_gain -= (nframes * session_removal_gain_step);
634 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
635 i->second->cycle_end (nframes);
638 _processed_frames = next_processed_frames;
646 AudioEngine::_sample_rate_callback (pframes_t nframes, void *arg)
648 return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
652 AudioEngine::jack_sample_rate_callback (pframes_t nframes)
654 _frame_rate = nframes;
655 _usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
657 /* check for monitor input change every 1/10th of second */
659 monitor_check_interval = nframes / 10;
660 last_monitor_check = 0;
663 _session->set_frame_rate (nframes);
666 SampleRateChanged (nframes); /* EMIT SIGNAL */
672 AudioEngine::jack_latency_callback (jack_latency_callback_mode_t mode)
675 _session->update_latency (mode == JackPlaybackLatency);
680 AudioEngine::_bufsize_callback (pframes_t nframes, void *arg)
682 return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
686 AudioEngine::jack_bufsize_callback (pframes_t nframes)
688 /* if the size has not changed, this should be a no-op */
690 if (nframes == _buffer_size) {
694 GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
696 _buffer_size = nframes;
697 _usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
698 last_monitor_check = 0;
700 if (jack_port_type_get_buffer_size) {
701 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
702 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
705 /* Old version of JACK.
707 These crude guesses, see below where we try to get the right answers.
709 Note that our guess for MIDI deliberatey tries to overestimate
710 by a little. It would be nicer if we could get the actual
711 size from a port, but we have to use this estimate in the
712 event that there are no MIDI ports currently. If there are
713 the value will be adjusted below.
716 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
717 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
721 Glib::Threads::Mutex::Lock lm (_process_lock);
723 boost::shared_ptr<Ports> p = ports.reader();
725 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
731 _session->set_block_size (_buffer_size);
738 AudioEngine::stop_metering_thread ()
740 if (m_meter_thread) {
741 g_atomic_int_set (&m_meter_exit, 1);
742 m_meter_thread->join ();
748 AudioEngine::start_metering_thread ()
750 if (m_meter_thread == 0) {
751 g_atomic_int_set (&m_meter_exit, 0);
752 m_meter_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::meter_thread, this));
757 AudioEngine::meter_thread ()
759 pthread_set_name (X_("meter"));
761 Glib::usleep (10000);
762 if (g_atomic_int_get(&m_meter_exit)) {
770 AudioEngine::set_session (Session *s)
772 Glib::Threads::Mutex::Lock pl (_process_lock);
774 SessionHandlePtr::set_session (s);
778 start_metering_thread ();
780 pframes_t blocksize = jack_get_buffer_size (_jack);
782 /* page in as much of the session process code as we
783 can before we really start running.
786 boost::shared_ptr<Ports> p = ports.reader();
788 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
789 i->second->cycle_start (blocksize);
792 _session->process (blocksize);
793 _session->process (blocksize);
794 _session->process (blocksize);
795 _session->process (blocksize);
796 _session->process (blocksize);
797 _session->process (blocksize);
798 _session->process (blocksize);
799 _session->process (blocksize);
801 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
802 i->second->cycle_end (blocksize);
808 AudioEngine::remove_session ()
810 Glib::Threads::Mutex::Lock lm (_process_lock);
814 stop_metering_thread ();
817 session_remove_pending = true;
818 session_removed.wait(_process_lock);
822 SessionHandlePtr::set_session (0);
829 AudioEngine::port_registration_failure (const std::string& portname)
831 GET_PRIVATE_JACK_POINTER (_jack);
832 string full_portname = jack_client_name;
833 full_portname += ':';
834 full_portname += portname;
837 jack_port_t* p = jack_port_by_name (_priv_jack, full_portname.c_str());
841 reason = string_compose (_("a port with the name \"%1\" already exists: check for duplicated track/bus names"), portname);
843 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);
846 throw PortRegistrationFailure (string_compose (_("AudioEngine: cannot register port \"%1\": %2"), portname, reason).c_str());
849 boost::shared_ptr<Port>
850 AudioEngine::register_port (DataType dtype, const string& portname, bool input)
852 boost::shared_ptr<Port> newport;
855 if (dtype == DataType::AUDIO) {
856 newport.reset (new AudioPort (portname, (input ? Port::IsInput : Port::IsOutput)));
857 } else if (dtype == DataType::MIDI) {
858 newport.reset (new MidiPort (portname, (input ? Port::IsInput : Port::IsOutput)));
860 throw PortRegistrationFailure("unable to create port (unknown type)");
863 RCUWriter<Ports> writer (ports);
864 boost::shared_ptr<Ports> ps = writer.get_copy ();
865 ps->insert (make_pair (make_port_name_relative (portname), newport));
867 /* writer goes out of scope, forces update */
872 catch (PortRegistrationFailure& err) {
874 } catch (std::exception& e) {
875 throw PortRegistrationFailure(string_compose(
876 _("unable to create port: %1"), e.what()).c_str());
878 throw PortRegistrationFailure("unable to create port (unknown error)");
882 boost::shared_ptr<Port>
883 AudioEngine::register_input_port (DataType type, const string& portname)
885 return register_port (type, portname, true);
888 boost::shared_ptr<Port>
889 AudioEngine::register_output_port (DataType type, const string& portname)
891 return register_port (type, portname, false);
895 AudioEngine::unregister_port (boost::shared_ptr<Port> port)
897 /* caller must hold process lock */
900 /* probably happening when the engine has been halted by JACK,
901 in which case, there is nothing we can do here.
907 RCUWriter<Ports> writer (ports);
908 boost::shared_ptr<Ports> ps = writer.get_copy ();
909 Ports::iterator x = ps->find (make_port_name_relative (port->name()));
911 if (x != ps->end()) {
915 /* writer goes out of scope, forces update */
924 AudioEngine::connect (const string& source, const string& destination)
930 fatal << _("connect called before engine was started") << endmsg;
937 string s = make_port_name_non_relative (source);
938 string d = make_port_name_non_relative (destination);
941 boost::shared_ptr<Port> src = get_port_by_name (s);
942 boost::shared_ptr<Port> dst = get_port_by_name (d);
945 ret = src->connect (d);
947 ret = dst->connect (s);
949 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
954 /* already exists - no error, no warning */
955 } else if (ret < 0) {
956 error << string_compose(_("AudioEngine: cannot connect %1 (%2) to %3 (%4)"),
957 source, s, destination, d)
965 AudioEngine::disconnect (const string& source, const string& destination)
971 fatal << _("disconnect called before engine was started") << endmsg;
978 string s = make_port_name_non_relative (source);
979 string d = make_port_name_non_relative (destination);
981 boost::shared_ptr<Port> src = get_port_by_name (s);
982 boost::shared_ptr<Port> dst = get_port_by_name (d);
985 ret = src->disconnect (d);
987 ret = dst->disconnect (s);
989 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
996 AudioEngine::disconnect (boost::shared_ptr<Port> port)
998 GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
1002 fatal << _("disconnect called before engine was started") << endmsg;
1009 return port->disconnect_all ();
1013 AudioEngine::frame_rate () const
1015 GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1016 if (_frame_rate == 0) {
1017 return (_frame_rate = jack_get_sample_rate (_priv_jack));
1024 AudioEngine::raw_buffer_size (DataType t)
1026 std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
1027 return (s != _raw_buffer_sizes.end()) ? s->second : 0;
1031 AudioEngine::frames_per_cycle () const
1033 GET_PRIVATE_JACK_POINTER_RET (_jack,0);
1034 if (_buffer_size == 0) {
1035 return jack_get_buffer_size (_jack);
1037 return _buffer_size;
1041 /** @param name Full or short name of port
1042 * @return Corresponding Port or 0.
1045 boost::shared_ptr<Port>
1046 AudioEngine::get_port_by_name (const string& portname)
1050 fatal << _("get_port_by_name() called before engine was started") << endmsg;
1053 boost::shared_ptr<Port> ();
1057 if (!port_is_mine (portname)) {
1058 /* not an ardour port */
1059 return boost::shared_ptr<Port> ();
1062 boost::shared_ptr<Ports> pr = ports.reader();
1063 std::string rel = make_port_name_relative (portname);
1064 Ports::iterator x = pr->find (rel);
1066 if (x != pr->end()) {
1067 /* its possible that the port was renamed by some 3rd party and
1068 we don't know about it. check for this (the check is quick
1069 and cheap), and if so, rename the port (which will alter
1070 the port map as a side effect).
1072 const std::string check = make_port_name_relative (jack_port_name (x->second->jack_port()));
1074 x->second->set_name (check);
1079 return boost::shared_ptr<Port> ();
1083 AudioEngine::port_renamed (const std::string& old_relative_name, const std::string& new_relative_name)
1085 RCUWriter<Ports> writer (ports);
1086 boost::shared_ptr<Ports> p = writer.get_copy();
1087 Ports::iterator x = p->find (old_relative_name);
1089 if (x != p->end()) {
1090 boost::shared_ptr<Port> port = x->second;
1092 p->insert (make_pair (new_relative_name, port));
1097 AudioEngine::get_ports (const string& port_name_pattern, const string& type_name_pattern, uint32_t flags)
1099 GET_PRIVATE_JACK_POINTER_RET (_jack,0);
1102 fatal << _("get_ports called before engine was started") << endmsg;
1108 return jack_get_ports (_priv_jack, port_name_pattern.c_str(), type_name_pattern.c_str(), flags);
1112 AudioEngine::halted_info (jack_status_t code, const char* reason, void *arg)
1114 /* called from jack shutdown handler */
1116 AudioEngine* ae = static_cast<AudioEngine *> (arg);
1117 bool was_running = ae->_running;
1119 ae->stop_metering_thread ();
1121 ae->_running = false;
1122 ae->_buffer_size = 0;
1123 ae->_frame_rate = 0;
1127 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
1128 #ifdef HAVE_JACK_ON_INFO_SHUTDOWN
1130 case JackBackendError:
1131 ae->Halted(reason); /* EMIT SIGNAL */
1134 ae->Halted(""); /* EMIT SIGNAL */
1137 ae->Halted(""); /* EMIT SIGNAL */
1143 AudioEngine::halted (void *arg)
1145 cerr << "HALTED by JACK\n";
1147 /* called from jack shutdown handler */
1149 AudioEngine* ae = static_cast<AudioEngine *> (arg);
1150 bool was_running = ae->_running;
1152 ae->stop_metering_thread ();
1154 ae->_running = false;
1155 ae->_buffer_size = 0;
1156 ae->_frame_rate = 0;
1160 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
1161 ae->Halted(""); /* EMIT SIGNAL */
1166 AudioEngine::died ()
1168 /* called from a signal handler for SIGPIPE */
1170 stop_metering_thread ();
1179 AudioEngine::can_request_hardware_monitoring ()
1181 GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1182 const char ** ports;
1184 if ((ports = jack_get_ports (_priv_jack, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortCanMonitor)) == 0) {
1194 AudioEngine::n_physical (unsigned long flags) const
1198 GET_PRIVATE_JACK_POINTER_RET (_jack, c);
1200 const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1205 for (uint32_t i = 0; ports[i]; ++i) {
1206 if (!strstr (ports[i], "Midi-Through")) {
1207 DataType t (jack_port_type (jack_port_by_name (_jack, ports[i])));
1208 c.set (t, c.get (t) + 1);
1218 AudioEngine::n_physical_inputs () const
1220 return n_physical (JackPortIsInput);
1224 AudioEngine::n_physical_outputs () const
1226 return n_physical (JackPortIsOutput);
1230 AudioEngine::get_physical (DataType type, unsigned long flags, vector<string>& phy)
1232 GET_PRIVATE_JACK_POINTER (_jack);
1233 const char ** ports;
1235 if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical | flags)) == 0) {
1240 for (uint32_t i = 0; ports[i]; ++i) {
1241 if (strstr (ports[i], "Midi-Through")) {
1244 phy.push_back (ports[i]);
1250 /** Get physical ports for which JackPortIsOutput is set; ie those that correspond to
1251 * a physical input connector.
1254 AudioEngine::get_physical_inputs (DataType type, vector<string>& ins)
1256 get_physical (type, JackPortIsOutput, ins);
1259 /** Get physical ports for which JackPortIsInput is set; ie those that correspond to
1260 * a physical output connector.
1263 AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
1265 get_physical (type, JackPortIsInput, outs);
1269 AudioEngine::transport_stop ()
1271 GET_PRIVATE_JACK_POINTER (_jack);
1272 jack_transport_stop (_priv_jack);
1276 AudioEngine::transport_start ()
1278 GET_PRIVATE_JACK_POINTER (_jack);
1279 jack_transport_start (_priv_jack);
1283 AudioEngine::transport_locate (framepos_t where)
1285 GET_PRIVATE_JACK_POINTER (_jack);
1286 jack_transport_locate (_priv_jack, where);
1289 AudioEngine::TransportState
1290 AudioEngine::transport_state ()
1292 GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
1293 jack_position_t pos;
1294 return (TransportState) jack_transport_query (_priv_jack, &pos);
1298 AudioEngine::reset_timebase ()
1300 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1302 if (_session->config.get_jack_time_master()) {
1303 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
1305 return jack_release_timebase (_jack);
1312 AudioEngine::freewheel (bool onoff)
1314 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1316 if (onoff != _freewheeling) {
1317 return jack_set_freewheel (_priv_jack, onoff);
1320 /* already doing what has been asked for */
1326 AudioEngine::remove_all_ports ()
1328 /* make sure that JACK callbacks that will be invoked as we cleanup
1329 * ports know that they have nothing to do.
1332 port_remove_in_progress = true;
1334 /* process lock MUST be held by caller
1338 RCUWriter<Ports> writer (ports);
1339 boost::shared_ptr<Ports> ps = writer.get_copy ();
1343 /* clear dead wood list in RCU */
1347 port_remove_in_progress = false;
1351 AudioEngine::connect_to_jack (string client_name, string session_uuid)
1353 EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
1354 boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
1355 jack_status_t status;
1357 /* revert all environment settings back to whatever they were when ardour started
1361 current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
1362 global_epa->restore ();
1365 jack_client_name = client_name; /* might be reset below */
1366 #ifdef HAVE_JACK_SESSION
1367 if (! session_uuid.empty())
1368 _jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
1371 _jack = jack_client_open (jack_client_name.c_str(), JackNullOption, &status, 0);
1373 if (_jack == NULL) {
1374 // error message is not useful here
1378 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1380 if (status & JackNameNotUnique) {
1381 jack_client_name = jack_get_client_name (_priv_jack);
1388 AudioEngine::disconnect_from_jack ()
1390 GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1393 stop_metering_thread ();
1397 Glib::Threads::Mutex::Lock lm (_process_lock);
1398 jack_client_close (_priv_jack);
1404 _raw_buffer_sizes.clear();
1408 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
1409 Stopped(); /* EMIT SIGNAL */
1416 AudioEngine::reconnect_to_jack ()
1419 disconnect_from_jack ();
1420 /* XXX give jackd a chance */
1421 Glib::usleep (250000);
1424 if (connect_to_jack (jack_client_name, "")) {
1425 error << _("failed to connect to JACK") << endmsg;
1431 boost::shared_ptr<Ports> p = ports.reader ();
1433 for (i = p->begin(); i != p->end(); ++i) {
1434 if (i->second->reestablish ()) {
1439 if (i != p->end()) {
1441 remove_all_ports ();
1445 GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
1447 MIDI::Manager::instance()->reestablish (_priv_jack);
1450 _session->reset_jack_connection (_priv_jack);
1451 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
1452 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
1455 last_monitor_check = 0;
1457 set_jack_callbacks ();
1459 if (jack_activate (_priv_jack) == 0) {
1466 /* re-establish connections */
1468 for (i = p->begin(); i != p->end(); ++i) {
1469 i->second->reconnect ();
1472 MIDI::Manager::instance()->reconnect ();
1474 Running (); /* EMIT SIGNAL*/
1476 start_metering_thread ();
1482 AudioEngine::request_buffer_size (pframes_t nframes)
1484 GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1486 if (nframes == jack_get_buffer_size (_priv_jack)) {
1490 return jack_set_buffer_size (_priv_jack, nframes);
1494 AudioEngine::make_port_name_relative (string portname) const
1496 string::size_type len;
1497 string::size_type n;
1499 len = portname.length();
1501 for (n = 0; n < len; ++n) {
1502 if (portname[n] == ':') {
1507 if ((n != len) && (portname.substr (0, n) == jack_client_name)) {
1508 return portname.substr (n+1);
1515 AudioEngine::make_port_name_non_relative (string portname) const
1519 if (portname.find_first_of (':') != string::npos) {
1523 str = jack_client_name;
1531 AudioEngine::port_is_mine (const string& portname) const
1533 if (portname.find_first_of (':') != string::npos) {
1534 if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
1542 AudioEngine::is_realtime () const
1544 GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1545 return jack_is_realtime (_priv_jack);
1549 AudioEngine::create_process_thread (boost::function<void()> f, jack_native_thread_t* thread, size_t stacksize)
1551 GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1552 ThreadData* td = new ThreadData (this, f, stacksize);
1554 if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
1555 jack_is_realtime (_priv_jack), _start_process_thread, td)) {
1563 AudioEngine::stop_process_thread (jack_native_thread_t thread)
1566 * can't use GET_PRIVATE_JACK_POINTER_RET (_jack, 0) here
1567 * because _jack is 0 when this is called. At least for
1568 * Jack 2 _jack arg is not used so it should be OK
1571 #if defined(USING_JACK2_EXPANSION_OF_JACK_API) || defined(WIN32)
1572 if (jack_client_stop_thread (_jack, thread) != 0) {
1573 error << "AudioEngine: cannot stop process thread" << endmsg;
1578 pthread_join (thread, &status);
1585 AudioEngine::_start_process_thread (void* arg)
1587 ThreadData* td = reinterpret_cast<ThreadData*> (arg);
1588 boost::function<void()> f = td->f;
1597 AudioEngine::port_is_physical (const std::string& portname) const
1599 GET_PRIVATE_JACK_POINTER_RET(_jack, false);
1601 jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1607 return jack_port_flags (port) & JackPortIsPhysical;
1611 AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const
1613 GET_PRIVATE_JACK_POINTER(_jack);
1615 jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1621 jack_port_request_monitor (port, yn);
1625 AudioEngine::update_latencies ()
1627 if (jack_recompute_total_latencies) {
1628 GET_PRIVATE_JACK_POINTER (_jack);
1629 jack_recompute_total_latencies (_priv_jack);
1634 AudioEngine::destroy ()