X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudioengine.cc;h=06a1637382ded9ede0c658a5571ad3e0fef8ecd9;hb=b087721d8aaf9470833414d01a72d826162946ab;hp=39c8d7153428311e598acda434a092941fecb111;hpb=922488427a09fdfd4f4685bb114bdc992680a39f;p=ardour.git diff --git a/libs/ardour/audioengine.cc b/libs/ardour/audioengine.cc index 39c8d71534..06a1637382 100644 --- a/libs/ardour/audioengine.cc +++ b/libs/ardour/audioengine.cc @@ -25,12 +25,13 @@ #include #include -#include -#include #include "pbd/pthread_utils.h" #include "pbd/stacktrace.h" #include "pbd/unknown_type.h" +#include "pbd/epa.h" + +#include #include "midi++/port.h" #include "midi++/mmc.h" @@ -76,7 +77,7 @@ AudioEngine::AudioEngine (string client_name, string session_uuid) _running = false; _has_run = false; last_monitor_check = 0; - monitor_check_interval = max_frames; + monitor_check_interval = INT32_MAX; _processed_frames = 0; _usecs_per_cycle = 0; _jack = 0; @@ -84,6 +85,7 @@ AudioEngine::AudioEngine (string client_name, string session_uuid) _buffer_size = 0; _freewheeling = false; _main_thread = 0; + port_remove_in_progress = false; m_meter_thread = 0; g_atomic_int_set (&m_meter_exit, 0); @@ -93,23 +95,6 @@ AudioEngine::AudioEngine (string client_name, string session_uuid) } Port::set_engine (this); - - // Initialize parameter metadata (e.g. ranges) - Evoral::Parameter p(NullAutomation); - p = EventTypeMap::instance().new_parameter(NullAutomation); - p = EventTypeMap::instance().new_parameter(GainAutomation); - p = EventTypeMap::instance().new_parameter(PanAutomation); - p = EventTypeMap::instance().new_parameter(PluginAutomation); - p = EventTypeMap::instance().new_parameter(SoloAutomation); - p = EventTypeMap::instance().new_parameter(MuteAutomation); - p = EventTypeMap::instance().new_parameter(MidiCCAutomation); - p = EventTypeMap::instance().new_parameter(MidiPgmChangeAutomation); - p = EventTypeMap::instance().new_parameter(MidiPitchBenderAutomation); - p = EventTypeMap::instance().new_parameter(MidiChannelPressureAutomation); - p = EventTypeMap::instance().new_parameter(FadeInAutomation); - p = EventTypeMap::instance().new_parameter(FadeOutAutomation); - p = EventTypeMap::instance().new_parameter(EnvelopeAutomation); - p = EventTypeMap::instance().new_parameter(MidiCCAutomation); } AudioEngine::~AudioEngine () @@ -150,25 +135,50 @@ _thread_init_callback (void * /*arg*/) MIDI::Port::set_process_thread (pthread_self()); } -typedef void (*_JackInfoShutdownCallback)(jack_status_t code, const char* reason, void *arg); - -static void (*on_info_shutdown)(jack_client_t*, _JackInfoShutdownCallback, void *); -extern void jack_on_info_shutdown (jack_client_t*, _JackInfoShutdownCallback, void *) __attribute__((weak)); - -static void check_jack_symbols () __attribute__((constructor)); - -void check_jack_symbols () -{ - /* use weak linking to see if we really have various late-model JACK function */ - on_info_shutdown = jack_on_info_shutdown; -} - 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 () { @@ -176,57 +186,28 @@ AudioEngine::start () if (!_running) { - nframes_t blocksize = jack_get_buffer_size (_priv_jack); + if (!jack_port_type_get_buffer_size) { + warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg; + } if (_session) { BootMessage (_("Connect session to engine")); - - _session->set_block_size (blocksize); _session->set_frame_rate (jack_get_sample_rate (_priv_jack)); - - /* page in as much of the session process code as we - can before we really start running. - */ - - _session->process (blocksize); - _session->process (blocksize); - _session->process (blocksize); - _session->process (blocksize); - _session->process (blocksize); - _session->process (blocksize); - _session->process (blocksize); - _session->process (blocksize); } - _processed_frames = 0; - last_monitor_check = 0; + /* a proxy for whether jack_activate() will definitely call the buffer size + * callback. with older versions of JACK, this function symbol will be null. + * this is reliable, but not clean. + */ - if (on_info_shutdown) { - jack_on_info_shutdown (_priv_jack, halted_info, this); - } else { - jack_on_shutdown (_priv_jack, halted, this); + if (!jack_port_type_get_buffer_size) { + jack_bufsize_callback (jack_get_buffer_size (_priv_jack)); } - jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this); - jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this); - // jack_set_process_callback (_priv_jack, _process_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_xrun_callback (_priv_jack, _xrun_callback, this); -#ifdef HAVE_JACK_SESSION - if( jack_set_session_callback ) - jack_set_session_callback (_priv_jack, _session_callback, this); -#endif - jack_set_sync_callback (_priv_jack, _jack_sync_callback, this); - jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this); - jack_set_port_registration_callback (_priv_jack, _registration_callback, this); - jack_set_port_connect_callback (_priv_jack, _connect_callback, this); - - if (_session && _session->config.get_jack_time_master()) { - jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this); - } + + _processed_frames = 0; + last_monitor_check = 0; - jack_set_error_function (ardour_jack_error); + set_jack_callbacks (); if (jack_activate (_priv_jack) == 0) { _running = true; @@ -235,19 +216,8 @@ AudioEngine::start () } else { // error << _("cannot activate JACK client") << endmsg; } - - _raw_buffer_sizes[DataType::AUDIO] = blocksize * sizeof(float); - - jack_port_t* midi_port = jack_port_register (_priv_jack, "m", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0); - if (!midi_port) { - error << _("Cannot create temporary MIDI port to determine MIDI buffer size") << endmsg; - } else { - _raw_buffer_sizes[DataType::MIDI] = jack_midi_max_event_size (jack_port_get_buffer(midi_port, blocksize)); - cerr << "MIDI port buffers = " << _raw_buffer_sizes[DataType::MIDI] << endl; - jack_port_unregister (_priv_jack, midi_port); - } } - + return _running ? 0 : -1; } @@ -266,12 +236,16 @@ AudioEngine::stop (bool forever) } } + if (forever) { + stop_metering_thread (); + } + return _running ? -1 : 0; } bool -AudioEngine::get_sync_offset (nframes_t& offset) const +AudioEngine::get_sync_offset (pframes_t& offset) const { #ifdef HAVE_JACK_VIDEO_SUPPORT @@ -297,14 +271,14 @@ AudioEngine::get_sync_offset (nframes_t& offset) const } void -AudioEngine::_jack_timebase_callback (jack_transport_state_t state, nframes_t nframes, +AudioEngine::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes, jack_position_t* pos, int new_position, void *arg) { static_cast (arg)->jack_timebase_callback (state, nframes, pos, new_position); } void -AudioEngine::jack_timebase_callback (jack_transport_state_t state, nframes_t nframes, +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()) { @@ -353,23 +327,14 @@ int AudioEngine::_graph_order_callback (void *arg) { AudioEngine* ae = static_cast (arg); - if (ae->connected()) { + + if (ae->connected() && !ae->port_remove_in_progress) { ae->GraphReordered (); /* EMIT SIGNAL */ } + return 0; } -/** Wrapped which is called by JACK as its process callback. It is just - * here to get us back into C++ land by calling AudioEngine::process_callback() - * @param nframes Number of frames passed by JACK. - * @param arg User argument passed by JACK, which will be the AudioEngine*. - */ -int -AudioEngine::_process_callback (nframes_t nframes, void *arg) -{ - return static_cast (arg)->process_callback (nframes); -} - void* AudioEngine::_process_thread (void *arg) { @@ -386,22 +351,59 @@ void AudioEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg) { AudioEngine* ae = static_cast (arg); - ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */ + + if (!ae->port_remove_in_progress) { + ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */ + } } void -AudioEngine::_connect_callback (jack_port_id_t /*id_a*/, jack_port_id_t /*id_b*/, int /*conn*/, void* arg) +AudioEngine::_latency_callback (jack_latency_callback_mode_t mode, void* arg) +{ + return static_cast (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 (arg); - ae->PortConnectedOrDisconnected (); /* EMIT SIGNAL */ + + if (ae->port_remove_in_progress) { + return; + } + + GET_PRIVATE_JACK_POINTER (ae->_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_a; + boost::shared_ptr port_b; + + boost::shared_ptr pr = ae->ports.reader (); + Ports::iterator i = pr->begin (); + while (i != pr->end() && (port_a == 0 || port_b == 0)) { + if (jack_port_a == (*i)->jack_port()) { + port_a = *i; + } else if (jack_port_b == (*i)->jack_port()) { + port_b = *i; + } + ++i; + } + + ae->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 (nframes_t offset) +AudioEngine::split_cycle (pframes_t offset) { /* caller must hold process lock */ - Port::increment_port_offset (offset); + Port::increment_global_port_buffer_offset (offset); /* tell all Ports that we're going to start a new (split) cycle */ @@ -412,17 +414,10 @@ AudioEngine::split_cycle (nframes_t offset) } } -void -AudioEngine::finish_process_cycle (int status) -{ - GET_PRIVATE_JACK_POINTER(_jack); - jack_cycle_signal (_jack, 0); -} - void* AudioEngine::process_thread () { - /* JACK doesn't do this for us when we use the wait API + /* JACK doesn't do this for us when we use the wait API */ _thread_init_callback (0); @@ -431,37 +426,38 @@ AudioEngine::process_thread () while (1) { GET_PRIVATE_JACK_POINTER_RET(_jack,0); - jack_nframes_t nframes = jack_cycle_wait (_jack); + + pframes_t nframes = jack_cycle_wait (_priv_jack); if (process_callback (nframes)) { - cerr << "--- process\n"; return 0; } - finish_process_cycle (0); + jack_cycle_signal (_priv_jack, 0); } return 0; } -/** Method called by JACK (via _process_callback) which says that there - * is work to be done. - * @param nframes Number of frames to process. +/** Method called by our ::process_thread when there is work to be done. + * @param nframes Number of frames to process. */ int -AudioEngine::process_callback (nframes_t nframes) +AudioEngine::process_callback (pframes_t nframes) { GET_PRIVATE_JACK_POINTER_RET(_jack,0); - // CycleTimer ct ("AudioEngine::process"); Glib::Mutex::Lock tm (_process_lock, Glib::TRY_LOCK); + PT_TIMING_REF; + PT_TIMING_CHECK (1); + /// The number of frames that will have been processed when we've finished - nframes_t next_processed_frames; + pframes_t next_processed_frames; /* handle wrap around of total frames counter */ - if (max_frames - _processed_frames < nframes) { - next_processed_frames = nframes - (max_frames - _processed_frames); + if (max_framepos - _processed_frames < nframes) { + next_processed_frames = nframes - (max_framepos - _processed_frames); } else { next_processed_frames = _processed_frames + nframes; } @@ -484,8 +480,8 @@ AudioEngine::process_callback (nframes_t nframes) /* tell all relevant objects that we're starting a new cycle */ Delivery::CycleStart (nframes); - Port::set_port_offset (0); - InternalReturn::CycleStart (nframes); + Port::set_global_port_buffer_offset (0); + Port::set_cycle_framecnt (nframes); /* tell all Ports that we're starting a new cycle */ @@ -500,7 +496,7 @@ AudioEngine::process_callback (nframes_t nframes) if (_freewheeling && !Freewheel.empty()) { - /* emit the Freewheel signal and stop freewheeling in the event of trouble + /* emit the Freewheel signal and stop freewheeling in the event of trouble */ boost::optional r = Freewheel (nframes); if (r.get_value_or (0)) { @@ -510,7 +506,6 @@ AudioEngine::process_callback (nframes_t nframes) } else { if (_session) { _session->process (nframes); - } } @@ -529,15 +524,14 @@ AudioEngine::process_callback (nframes_t nframes) for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - Port *port = (*i); bool x; - if (port->_last_monitor != (x = port->monitoring_input ())) { - port->_last_monitor = x; + if ((*i)->last_monitor() != (x = (*i)->jack_monitoring_input ())) { + (*i)->set_last_monitor (x); /* XXX I think this is dangerous, due to a likely mutex in the signal handlers ... */ - port->MonitorInputChanged (x); /* EMIT SIGNAL */ + (*i)->MonitorInputChanged (x); /* EMIT SIGNAL */ } } last_monitor_check = next_processed_frames; @@ -549,10 +543,8 @@ AudioEngine::process_callback (nframes_t nframes) for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - Port *port = (*i); - - if (port->sends_output()) { - port->get_buffer(nframes).silence(nframes); + if ((*i)->sends_output()) { + (*i)->get_buffer(nframes).silence(nframes); } } } @@ -564,17 +556,20 @@ AudioEngine::process_callback (nframes_t nframes) } _processed_frames = next_processed_frames; + + PT_TIMING_CHECK (2); + return 0; } int -AudioEngine::_sample_rate_callback (nframes_t nframes, void *arg) +AudioEngine::_sample_rate_callback (pframes_t nframes, void *arg) { return static_cast (arg)->jack_sample_rate_callback (nframes); } int -AudioEngine::jack_sample_rate_callback (nframes_t nframes) +AudioEngine::jack_sample_rate_callback (pframes_t nframes) { _frame_rate = nframes; _usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0); @@ -593,50 +588,63 @@ AudioEngine::jack_sample_rate_callback (nframes_t nframes) return 0; } +void +AudioEngine::jack_latency_callback (jack_latency_callback_mode_t mode) +{ + if (_session) { + _session->update_latency (mode == JackPlaybackLatency); + } +} + int -AudioEngine::_bufsize_callback (nframes_t nframes, void *arg) +AudioEngine::_bufsize_callback (pframes_t nframes, void *arg) { return static_cast (arg)->jack_bufsize_callback (nframes); } int -AudioEngine::jack_bufsize_callback (nframes_t nframes) +AudioEngine::jack_bufsize_callback (pframes_t nframes) { - bool need_midi_size = true; - bool need_audio_size = true; + /* 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; - boost::shared_ptr p = ports.reader(); + 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 { - /* crude guesses, see below where we try to get the right answers. + /* Old version of JACK. - 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. - */ + These crude guesses, see below where we try to get the right answers. - _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample); - _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2); + 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. + */ - for (Ports::iterator i = p->begin(); i != p->end(); ++i) { + _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample); + _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2); + } - if (need_audio_size && (*i)->type() == DataType::AUDIO) { - _raw_buffer_sizes[DataType::AUDIO] = (*i)->raw_buffer_size (nframes); - need_audio_size = false; - } - - - if (need_midi_size && (*i)->type() == DataType::MIDI) { - _raw_buffer_sizes[DataType::MIDI] = (*i)->raw_buffer_size (nframes); - need_midi_size = false; - } - - (*i)->reset(); + { + Glib::Mutex::Lock lm (_process_lock); + + boost::shared_ptr p = ports.reader(); + + for (Ports::iterator i = p->begin(); i != p->end(); ++i) { + (*i)->reset(); + } } if (_session) { @@ -690,19 +698,19 @@ AudioEngine::set_session (Session *s) if (_session) { start_metering_thread (); - - nframes_t blocksize = jack_get_buffer_size (_jack); - + + pframes_t blocksize = jack_get_buffer_size (_jack); + /* page in as much of the session process code as we can before we really start running. */ - + boost::shared_ptr p = ports.reader(); - + for (Ports::iterator i = p->begin(); i != p->end(); ++i) { (*i)->cycle_start (blocksize); } - + _session->process (blocksize); _session->process (blocksize); _session->process (blocksize); @@ -711,7 +719,7 @@ AudioEngine::set_session (Session *s) _session->process (blocksize); _session->process (blocksize); _session->process (blocksize); - + for (Ports::iterator i = p->begin(); i != p->end(); ++i) { (*i)->cycle_end (blocksize); } @@ -760,26 +768,20 @@ AudioEngine::port_registration_failure (const std::string& portname) throw PortRegistrationFailure (string_compose (_("AudioEngine: cannot register port \"%1\": %2"), portname, reason).c_str()); } -Port * +boost::shared_ptr AudioEngine::register_port (DataType dtype, const string& portname, bool input) { - Port* newport = 0; + boost::shared_ptr newport; try { if (dtype == DataType::AUDIO) { - newport = new AudioPort (portname, (input ? Port::IsInput : Port::IsOutput)); + newport.reset (new AudioPort (portname, (input ? Port::IsInput : Port::IsOutput))); } else if (dtype == DataType::MIDI) { - newport = new MidiPort (portname, (input ? Port::IsInput : Port::IsOutput)); + newport.reset (new MidiPort (portname, (input ? Port::IsInput : Port::IsOutput))); } else { throw PortRegistrationFailure("unable to create port (unknown type)"); } - size_t& old_buffer_size = _raw_buffer_sizes[newport->type()]; - size_t port_buffer_size = newport->raw_buffer_size(0); - if (port_buffer_size > old_buffer_size) { - old_buffer_size = port_buffer_size; - } - RCUWriter writer (ports); boost::shared_ptr ps = writer.get_copy (); ps->insert (ps->begin(), newport); @@ -799,20 +801,20 @@ AudioEngine::register_port (DataType dtype, const string& portname, bool input) } } -Port * +boost::shared_ptr AudioEngine::register_input_port (DataType type, const string& portname) { return register_port (type, portname, true); } -Port * +boost::shared_ptr AudioEngine::register_output_port (DataType type, const string& portname) { return register_port (type, portname, false); } int -AudioEngine::unregister_port (Port& port) +AudioEngine::unregister_port (boost::shared_ptr port) { /* caller must hold process lock */ @@ -826,26 +828,19 @@ AudioEngine::unregister_port (Port& port) { RCUWriter writer (ports); boost::shared_ptr ps = writer.get_copy (); - - for (Ports::iterator i = ps->begin(); i != ps->end(); ++i) { - if ((*i) == &port) { - delete *i; - ps->erase (i); - break; - } - } + ps->erase (port); /* writer goes out of scope, forces update */ } + ports.flush (); + return 0; } int AudioEngine::connect (const string& source, const string& destination) { - /* caller must hold process lock */ - int ret; if (!_running) { @@ -861,8 +856,8 @@ AudioEngine::connect (const string& source, const string& destination) string d = make_port_name_non_relative (destination); - Port* src = get_port_by_name_locked (s); - Port* dst = get_port_by_name_locked (d); + boost::shared_ptr src = get_port_by_name (s); + boost::shared_ptr dst = get_port_by_name (d); if (src) { ret = src->connect (d); @@ -887,8 +882,6 @@ AudioEngine::connect (const string& source, const string& destination) int AudioEngine::disconnect (const string& source, const string& destination) { - /* caller must hold process lock */ - int ret; if (!_running) { @@ -903,8 +896,8 @@ AudioEngine::disconnect (const string& source, const string& destination) string s = make_port_name_non_relative (source); string d = make_port_name_non_relative (destination); - Port* src = get_port_by_name_locked (s); - Port* dst = get_port_by_name_locked (d); + boost::shared_ptr src = get_port_by_name (s); + boost::shared_ptr dst = get_port_by_name (d); if (src) { ret = src->disconnect (d); @@ -918,7 +911,7 @@ AudioEngine::disconnect (const string& source, const string& destination) } int -AudioEngine::disconnect (Port& port) +AudioEngine::disconnect (boost::shared_ptr port) { GET_PRIVATE_JACK_POINTER_RET (_jack,-1); @@ -931,17 +924,17 @@ AudioEngine::disconnect (Port& port) } } - return port.disconnect_all (); + return port->disconnect_all (); } -ARDOUR::nframes_t +ARDOUR::framecnt_t AudioEngine::frame_rate () const { - GET_PRIVATE_JACK_POINTER_RET (_jack,0); + GET_PRIVATE_JACK_POINTER_RET (_jack, 0); if (_frame_rate == 0) { - return (_frame_rate = jack_get_sample_rate (_priv_jack)); + return (_frame_rate = jack_get_sample_rate (_priv_jack)); } else { - return _frame_rate; + return _frame_rate; } } @@ -952,53 +945,37 @@ AudioEngine::raw_buffer_size (DataType t) return (s != _raw_buffer_sizes.end()) ? s->second : 0; } -ARDOUR::nframes_t +ARDOUR::pframes_t AudioEngine::frames_per_cycle () const { GET_PRIVATE_JACK_POINTER_RET (_jack,0); if (_buffer_size == 0) { - return (_buffer_size = jack_get_buffer_size (_jack)); + return jack_get_buffer_size (_jack); } else { - return _buffer_size; + return _buffer_size; } } -/** @param name Full name of port (including prefix:) - * @return Corresponding Port*, or 0. This object remains the property of the AudioEngine - * so must not be deleted. +/** @param name Full or short name of port + * @return Corresponding Port or 0. */ -Port * -AudioEngine::get_port_by_name (const string& portname) -{ - string s; - if (portname.find_first_of (':') == string::npos) { - s = make_port_name_non_relative (portname); - } else { - s = portname; - } - - Glib::Mutex::Lock lm (_process_lock); - return get_port_by_name_locked (s); -} -Port * -AudioEngine::get_port_by_name_locked (const string& portname) +boost::shared_ptr +AudioEngine::get_port_by_name (const string& portname) { - /* caller must hold process lock */ - if (!_running) { if (!_has_run) { - fatal << _("get_port_by_name_locked() called before engine was started") << endmsg; + fatal << _("get_port_by_name() called before engine was started") << endmsg; /*NOTREACHED*/ } else { - return 0; + boost::shared_ptr (); } } - if (portname.substr (0, jack_client_name.length ()) != jack_client_name) { - /* not an ardour: port */ - return 0; - } + if (!port_is_mine (portname)) { + /* not an ardour port */ + return boost::shared_ptr (); + } std::string const rel = make_port_name_relative (portname); @@ -1010,7 +987,7 @@ AudioEngine::get_port_by_name_locked (const string& portname) } } - return 0; + return boost::shared_ptr (); } const char ** @@ -1032,17 +1009,17 @@ void AudioEngine::halted_info (jack_status_t code, const char* reason, void *arg) { /* called from jack shutdown handler */ - + AudioEngine* ae = static_cast (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) { #ifdef HAVE_JACK_ON_INFO_SHUTDOWN switch (code) { @@ -1113,7 +1090,7 @@ ChanCount AudioEngine::n_physical (unsigned long flags) const { ChanCount c; - + GET_PRIVATE_JACK_POINTER_RET (_jack, c); const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags); @@ -1166,52 +1143,22 @@ AudioEngine::get_physical (DataType type, unsigned long flags, vector& p } } +/** Get physical ports for which JackPortIsOutput is set; ie those that correspond to + * a physical input connector. + */ void AudioEngine::get_physical_inputs (DataType type, vector& ins) { - get_physical (type, JackPortIsInput, ins); + get_physical (type, JackPortIsOutput, ins); } +/** Get physical ports for which JackPortIsInput is set; ie those that correspond to + * a physical output connector. + */ void AudioEngine::get_physical_outputs (DataType type, vector& outs) { - get_physical (type, JackPortIsOutput, outs); -} - -string -AudioEngine::get_nth_physical (DataType type, uint32_t n, int flag) -{ - GET_PRIVATE_JACK_POINTER_RET (_jack,""); - const char ** ports; - uint32_t i; - uint32_t idx; - string ret; - - assert(type != DataType::NIL); - - if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical|flag)) == 0) { - return ret; - } - - for (i = 0, idx = 0; idx < n && ports[i]; ++i) { - if (!strstr (ports[i], "Midi-Through")) { - ++idx; - } - } - - if (ports[idx]) { - ret = ports[idx]; - } - - free ((const char **) ports); - - return ret; -} - -void -AudioEngine::update_total_latency (const Port& port) -{ - port.recompute_total_latency (); + get_physical (type, JackPortIsInput, outs); } void @@ -1229,10 +1176,9 @@ AudioEngine::transport_start () } void -AudioEngine::transport_locate (nframes_t where) +AudioEngine::transport_locate (framepos_t where) { GET_PRIVATE_JACK_POINTER (_jack); - // cerr << "tell JACK to locate to " << where << endl; jack_transport_locate (_priv_jack, where); } @@ -1265,7 +1211,7 @@ AudioEngine::freewheel (bool onoff) if (onoff != _freewheeling) { return jack_set_freewheel (_priv_jack, onoff); - + } else { /* already doing what has been asked for */ return 0; @@ -1275,31 +1221,45 @@ AudioEngine::freewheel (bool onoff) void AudioEngine::remove_all_ports () { - /* process lock MUST be held */ + /* make sure that JACK callbacks that will be invoked as we cleanup + * ports know that they have nothing to do. + */ + + port_remove_in_progress = true; + + /* process lock MUST be held by caller + */ { RCUWriter writer (ports); boost::shared_ptr ps = writer.get_copy (); - - for (Ports::iterator i = ps->begin(); i != ps->end(); ++i) { - delete *i; - } - ps->clear (); } - /* clear dead wood list too */ + /* clear dead wood list in RCU */ ports.flush (); + + 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 current_epa; jack_options_t options = JackNullOption; jack_status_t status; const char *server_name = NULL; + /* 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()) @@ -1383,7 +1343,7 @@ AudioEngine::reconnect_to_jack () 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)); @@ -1392,24 +1352,7 @@ AudioEngine::reconnect_to_jack () last_monitor_check = 0; - jack_on_shutdown (_priv_jack, halted, this); - jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this); - jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this); - // jack_set_process_callback (_priv_jack, _process_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_xrun_callback (_priv_jack, _xrun_callback, this); -#ifdef HAVE_JACK_SESSION - if( jack_set_session_callback ) - jack_set_session_callback (_priv_jack, _session_callback, this); -#endif - 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); - } + set_jack_callbacks (); if (jack_activate (_priv_jack) == 0) { _running = true; @@ -1434,28 +1377,19 @@ AudioEngine::reconnect_to_jack () } int -AudioEngine::request_buffer_size (nframes_t nframes) +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 0; } - - return jack_set_buffer_size (_priv_jack, nframes); -} -void -AudioEngine::update_total_latencies () -{ -#ifdef HAVE_JACK_RECOMPUTE_LATENCIES - GET_PRIVATE_JACK_POINTER (_jack); - jack_recompute_total_latencies (_priv_jack); -#endif + return jack_set_buffer_size (_priv_jack, nframes); } string -AudioEngine::make_port_name_relative (string portname) +AudioEngine::make_port_name_relative (string portname) const { string::size_type len; string::size_type n; @@ -1476,7 +1410,7 @@ AudioEngine::make_port_name_relative (string portname) } string -AudioEngine::make_port_name_non_relative (string portname) +AudioEngine::make_port_name_non_relative (string portname) const { string str; @@ -1491,6 +1425,17 @@ AudioEngine::make_port_name_non_relative (string portname) return str; } +bool +AudioEngine::port_is_mine (const string& portname) const +{ + if (portname.find_first_of (':') != string::npos) { + if (portname.substr (0, jack_client_name.length ()) != jack_client_name) { + return false; + } + } + return true; +} + bool AudioEngine::is_realtime () const { @@ -1498,19 +1443,18 @@ AudioEngine::is_realtime () const return jack_is_realtime (_priv_jack); } -pthread_t -AudioEngine::create_process_thread (boost::function f, size_t stacksize) +int +AudioEngine::create_process_thread (boost::function f, pthread_t* thread, size_t stacksize) { GET_PRIVATE_JACK_POINTER_RET (_jack, 0); - pthread_t thread; ThreadData* td = new ThreadData (this, f, stacksize); - if (jack_client_create_thread (_priv_jack, &thread, jack_client_real_time_priority (_priv_jack), + 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 thread; + return 0; } void* @@ -1524,3 +1468,47 @@ AudioEngine::_start_process_thread (void* arg) return 0; } + +bool +AudioEngine::port_is_physical (const std::string& portname) const +{ + GET_PRIVATE_JACK_POINTER_RET(_jack, false); + + jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str()); + + if (!port) { + return false; + } + + return jack_port_flags (port) & JackPortIsPhysical; +} + +void +AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const +{ + GET_PRIVATE_JACK_POINTER(_jack); + + jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str()); + + if (!port) { + return; + } + + jack_port_request_monitor (port, yn); +} + +void +AudioEngine::update_latencies () +{ + if (jack_recompute_total_latencies) { + GET_PRIVATE_JACK_POINTER (_jack); + jack_recompute_total_latencies (_priv_jack); + } +} + +void +AudioEngine::destroy () +{ + delete _instance; + _instance = 0; +}