X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudioengine.cc;h=004ba33a6e235e4bc98731cee347d927ff5bf765;hb=80d9eaf96cd00f3084d18c32b4b31aabda0e6737;hp=cc6e3b443acd59080a4b700af02d275886c52074;hpb=bf806a87c3e53d60fa881d91973839f410001c3a;p=ardour.git diff --git a/libs/ardour/audioengine.cc b/libs/ardour/audioengine.cc index cc6e3b443a..004ba33a6e 100644 --- a/libs/ardour/audioengine.cc +++ b/libs/ardour/audioengine.cc @@ -25,37 +25,29 @@ #include #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++/jack_midi_port.h" #include "midi++/mmc.h" #include "midi++/manager.h" -#include "ardour/amp.h" #include "ardour/audio_port.h" #include "ardour/audioengine.h" #include "ardour/buffer.h" -#include "ardour/buffer_set.h" #include "ardour/cycle_timer.h" -#include "ardour/delivery.h" -#include "ardour/event_type_map.h" -#include "ardour/internal_return.h" -#include "ardour/io.h" +#include "ardour/internal_send.h" #include "ardour/meter.h" #include "ardour/midi_port.h" -#include "ardour/process_thread.h" #include "ardour/port.h" -#include "ardour/port_set.h" +#include "ardour/process_thread.h" #include "ardour/session.h" -#include "ardour/timestamps.h" -#include "ardour/utils.h" #include "i18n.h" @@ -70,24 +62,26 @@ AudioEngine* AudioEngine::_instance = 0; #define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; } AudioEngine::AudioEngine (string client_name, string session_uuid) - : ports (new Ports) + : _jack (0) + , session_remove_pending (false) + , session_removal_countdown (-1) + , _running (false) + , _has_run (false) + , _buffer_size (0) + , _frame_rate (0) + , monitor_check_interval (INT32_MAX) + , last_monitor_check (0) + , _processed_frames (0) + , _freewheeling (false) + , _pre_freewheel_mmc_enabled (false) + , _usecs_per_cycle (0) + , port_remove_in_progress (false) + , m_meter_thread (0) + , _main_thread (0) + , ports (new Ports) { _instance = this; /* singleton */ - session_remove_pending = false; - _running = false; - _has_run = false; - last_monitor_check = 0; - monitor_check_interval = INT32_MAX; - _processed_frames = 0; - _usecs_per_cycle = 0; - _jack = 0; - _frame_rate = 0; - _buffer_size = 0; - _freewheeling = false; - _main_thread = 0; - - m_meter_thread = 0; g_atomic_int_set (&m_meter_exit, 0); if (connect_to_jack (client_name, session_uuid)) { @@ -95,25 +89,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(PanAzimuthAutomation); - p = EventTypeMap::instance().new_parameter(PanElevationAutomation); - p = EventTypeMap::instance().new_parameter(PanWidthAutomation); - 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 () @@ -151,7 +126,7 @@ _thread_init_callback (void * /*arg*/) SessionEvent::create_per_thread_pool (X_("Audioengine"), 512); - MIDI::Port::set_process_thread (pthread_self()); + MIDI::JackMIDIPort::set_process_thread (pthread_self()); } static void @@ -160,6 +135,44 @@ 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 () { @@ -167,62 +180,28 @@ AudioEngine::start () if (!_running) { - pframes_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 (jack_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 -#if HAVE_JACK_NEW_LATENCY - if (jack_set_latency_callback) { - jack_set_latency_callback (_priv_jack, _latency_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; @@ -231,18 +210,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)); - jack_port_unregister (_priv_jack, midi_port); - } } - + return _running ? 0 : -1; } @@ -257,7 +226,7 @@ AudioEngine::stop (bool forever) } else { jack_deactivate (_priv_jack); Stopped(); /* EMIT SIGNAL */ - MIDI::Port::JackHalted (); /* EMIT SIGNAL */ + MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */ } } @@ -341,34 +310,25 @@ AudioEngine::_xrun_callback (void *arg) void AudioEngine::_session_callback (jack_session_event_t *event, void *arg) { - printf( "helo.... " ); AudioEngine* ae = static_cast (arg); if (ae->connected()) { ae->JackSessionEvent ( event ); /* EMIT SIGNAL */ } } #endif + 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 (pframes_t nframes, void *arg) -{ - return static_cast (arg)->process_callback (nframes); -} - void* AudioEngine::_process_thread (void *arg) { @@ -378,14 +338,30 @@ AudioEngine::_process_thread (void *arg) void AudioEngine::_freewheel_callback (int onoff, void *arg) { - static_cast(arg)->_freewheeling = onoff; + static_cast(arg)->freewheel_callback (onoff); +} + +void +AudioEngine::freewheel_callback (int onoff) +{ + _freewheeling = onoff; + + if (onoff) { + _pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled (); + MIDI::Manager::instance()->mmc()->enable_send (false); + } else { + MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled); + } } void AudioEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg) { AudioEngine* ae = static_cast (arg); - ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */ + + if (!ae->port_remove_in_progress) { + ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */ + } } void @@ -399,26 +375,34 @@ AudioEngine::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int co { AudioEngine* ae = static_cast (arg); + 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); - Port* port_a = 0; - Port* port_b = 0; + 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; + if (jack_port_a == i->second->jack_port()) { + port_a = i->second; + } else if (jack_port_b == i->second->jack_port()) { + port_b = i->second; } ++i; } - - ae->PortConnectedOrDisconnected (port_a, port_b, conn == 0 ? false : true); /* EMIT SIGNAL */ + + 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 @@ -426,28 +410,21 @@ AudioEngine::split_cycle (pframes_t offset) { /* caller must hold process lock */ - AudioPort::increment_port_offset (offset); + Port::increment_global_port_buffer_offset (offset); /* tell all Ports that we're going to start a new (split) cycle */ boost::shared_ptr p = ports.reader(); for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - (*i)->cycle_split (); + i->second->cycle_split (); } } -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); @@ -456,30 +433,31 @@ AudioEngine::process_thread () while (1) { GET_PRIVATE_JACK_POINTER_RET(_jack,0); - pframes_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 (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 pframes_t next_processed_frames; @@ -491,33 +469,72 @@ AudioEngine::process_callback (pframes_t nframes) next_processed_frames = _processed_frames + nframes; } - if (!tm.locked() || _session == 0) { + if (!tm.locked()) { /* return having done nothing */ _processed_frames = next_processed_frames; return 0; } if (session_remove_pending) { + /* perform the actual session removal */ - _session = 0; - session_remove_pending = false; - session_removed.signal(); + + if (session_removal_countdown < 0) { + + /* fade out over 1 second */ + session_removal_countdown = _frame_rate/2; + session_removal_gain = 1.0; + session_removal_gain_step = 1.0/session_removal_countdown; + + } else if (session_removal_countdown > 0) { + + /* we'll be fading audio out. + + if this is the last time we do this as part + of session removal, do a MIDI panic now + to get MIDI stopped. This relies on the fact + that "immediate data" (aka "out of band data") from + MIDI tracks is *appended* after any other data, + so that it emerges after any outbound note ons, etc. + */ + + if (session_removal_countdown <= nframes) { + _session->midi_panic (); + } + + } else { + /* fade out done */ + _session = 0; + session_removal_countdown = -1; // reset to "not in progress" + session_remove_pending = false; + session_removed.signal(); // wakes up thread that initiated session removal + } + } + + if (_session == 0) { + + if (!_freewheeling) { + MIDI::Manager::instance()->cycle_start(nframes); + MIDI::Manager::instance()->cycle_end(); + } + _processed_frames = next_processed_frames; + return 0; } /* tell all relevant objects that we're starting a new cycle */ - Delivery::CycleStart (nframes); - AudioPort::set_port_offset (0); - InternalReturn::CycleStart (nframes); + InternalSend::CycleStart (nframes); + Port::set_global_port_buffer_offset (0); + Port::set_cycle_framecnt (nframes); /* tell all Ports that we're starting a new cycle */ boost::shared_ptr p = ports.reader(); for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - (*i)->cycle_start (nframes); + i->second->cycle_start (nframes); } /* test if we are freewheeling and there are freewheel signals connected. @@ -525,7 +542,7 @@ AudioEngine::process_callback (pframes_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)) { @@ -533,10 +550,13 @@ AudioEngine::process_callback (pframes_t nframes) } } else { + MIDI::Manager::instance()->cycle_start(nframes); + if (_session) { _session->process (nframes); - } + + MIDI::Manager::instance()->cycle_end(); } if (_freewheeling) { @@ -554,15 +574,14 @@ AudioEngine::process_callback (pframes_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->second->last_monitor() != (x = i->second->jack_monitoring_input ())) { + i->second->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->second->MonitorInputChanged (x); /* EMIT SIGNAL */ } } last_monitor_check = next_processed_frames; @@ -570,25 +589,52 @@ AudioEngine::process_callback (pframes_t nframes) if (_session->silent()) { - boost::shared_ptr p = ports.reader(); - for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - Port *port = (*i); + if (i->second->sends_output()) { + i->second->get_buffer(nframes).silence(nframes); + } + } + } + + if (session_remove_pending && session_removal_countdown) { + + for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - if (port->sends_output()) { - port->get_buffer(nframes).silence(nframes); + if (i->second->sends_output()) { + + boost::shared_ptr ap = boost::dynamic_pointer_cast (i->second); + if (ap) { + Sample* s = ap->engine_get_whole_audio_buffer (); + gain_t g = session_removal_gain; + + for (pframes_t n = 0; n < nframes; ++n) { + *s++ *= g; + g -= session_removal_gain_step; + } + } } } + + if (session_removal_countdown > nframes) { + session_removal_countdown -= nframes; + } else { + session_removal_countdown = 0; + } + + session_removal_gain -= (nframes * session_removal_gain_step); } // Finalize ports for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - (*i)->cycle_end (nframes); + i->second->cycle_end (nframes); } _processed_frames = next_processed_frames; + + PT_TIMING_CHECK (2); + return 0; } @@ -635,41 +681,46 @@ AudioEngine::_bufsize_callback (pframes_t nframes, void *arg) int 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->second->reset(); + } } if (_session) { @@ -723,19 +774,19 @@ AudioEngine::set_session (Session *s) if (_session) { start_metering_thread (); - + 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); + i->second->cycle_start (blocksize); } - + _session->process (blocksize); _session->process (blocksize); _session->process (blocksize); @@ -744,9 +795,9 @@ 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); + i->second->cycle_end (blocksize); } } } @@ -787,35 +838,29 @@ AudioEngine::port_registration_failure (const std::string& portname) if (p) { reason = string_compose (_("a port with the name \"%1\" already exists: check for duplicated track/bus names"), portname); } else { - reason = string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME); + 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); } 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); + ps->insert (make_pair (make_port_name_relative (portname), newport)); /* writer goes out of scope, forces update */ @@ -832,20 +877,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 */ @@ -859,18 +904,17 @@ AudioEngine::unregister_port (Port& port) { RCUWriter writer (ports); boost::shared_ptr ps = writer.get_copy (); + Ports::iterator x = ps->find (make_port_name_relative (port->name())); - for (Ports::iterator i = ps->begin(); i != ps->end(); ++i) { - if ((*i) == &port) { - delete *i; - ps->erase (i); - break; - } + if (x != ps->end()) { + ps->erase (x); } /* writer goes out of scope, forces update */ } + ports.flush (); + return 0; } @@ -892,8 +936,8 @@ AudioEngine::connect (const string& source, const string& destination) string d = make_port_name_non_relative (destination); - Port* src = get_port_by_name (s); - Port* dst = get_port_by_name (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); @@ -932,8 +976,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 (s); - Port* dst = get_port_by_name (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); @@ -947,7 +991,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); @@ -960,7 +1004,7 @@ AudioEngine::disconnect (Port& port) } } - return port.disconnect_all (); + return port->disconnect_all (); } ARDOUR::framecnt_t @@ -986,17 +1030,17 @@ 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; } } /** @param name Full or short name of port - * @return Corresponding Port*, or 0. This object remains the property of the AudioEngine - * so must not be deleted. + * @return Corresponding Port or 0. */ -Port * + +boost::shared_ptr AudioEngine::get_port_by_name (const string& portname) { if (!_running) { @@ -1004,28 +1048,47 @@ AudioEngine::get_port_by_name (const string& portname) fatal << _("get_port_by_name() called before engine was started") << endmsg; /*NOTREACHED*/ } else { - return 0; - } - } - - if (portname.find_first_of (':') != string::npos) { - if (portname.substr (0, jack_client_name.length ()) != jack_client_name) { - /* not an ardour: port */ - return 0; + boost::shared_ptr (); } } - std::string const rel = make_port_name_relative (portname); + if (!port_is_mine (portname)) { + /* not an ardour port */ + return boost::shared_ptr (); + } boost::shared_ptr pr = ports.reader(); - - for (Ports::iterator i = pr->begin(); i != pr->end(); ++i) { - if (rel == (*i)->name()) { - return *i; + std::string rel = make_port_name_relative (portname); + Ports::iterator x = pr->find (rel); + + if (x != pr->end()) { + /* its possible that the port was renamed by some 3rd party and + we don't know about it. check for this (the check is quick + and cheap), and if so, rename the port (which will alter + the port map as a side effect). + */ + const std::string check = make_port_name_relative (jack_port_name (x->second->jack_port())); + if (check != rel) { + x->second->set_name (check); } + return x->second; } - return 0; + return boost::shared_ptr (); +} + +void +AudioEngine::port_renamed (const std::string& old_relative_name, const std::string& new_relative_name) +{ + RCUWriter writer (ports); + boost::shared_ptr p = writer.get_copy(); + Ports::iterator x = p->find (old_relative_name); + + if (x != p->end()) { + boost::shared_ptr port = x->second; + p->erase (x); + p->insert (make_pair (new_relative_name, port)); + } } const char ** @@ -1047,17 +1110,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) { @@ -1092,7 +1155,7 @@ AudioEngine::halted (void *arg) if (was_running) { ae->Halted(""); /* EMIT SIGNAL */ - MIDI::Port::JackHalted (); /* EMIT SIGNAL */ + MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */ } } @@ -1128,7 +1191,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); @@ -1199,12 +1262,6 @@ AudioEngine::get_physical_outputs (DataType type, vector& outs) get_physical (type, JackPortIsInput, outs); } -void -AudioEngine::update_total_latency (const Port& port) -{ - port.recompute_total_latency (); -} - void AudioEngine::transport_stop () { @@ -1223,7 +1280,6 @@ void 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); } @@ -1256,7 +1312,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; @@ -1266,22 +1322,26 @@ 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 @@ -1289,9 +1349,7 @@ 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 */ @@ -1307,7 +1365,7 @@ AudioEngine::connect_to_jack (string client_name, string session_uuid) _jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str()); else #endif - _jack = jack_client_open (jack_client_name.c_str(), options, &status, server_name); + _jack = jack_client_open (jack_client_name.c_str(), JackNullOption, &status, 0); if (_jack == NULL) { // error message is not useful here @@ -1345,7 +1403,7 @@ AudioEngine::disconnect_from_jack () if (_running) { _running = false; Stopped(); /* EMIT SIGNAL */ - MIDI::Port::JackHalted (); /* EMIT SIGNAL */ + MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */ } return 0; @@ -1370,7 +1428,7 @@ AudioEngine::reconnect_to_jack () boost::shared_ptr p = ports.reader (); for (i = p->begin(); i != p->end(); ++i) { - if ((*i)->reestablish ()) { + if (i->second->reestablish ()) { break; } } @@ -1384,7 +1442,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)); @@ -1393,24 +1451,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; @@ -1422,7 +1463,7 @@ AudioEngine::reconnect_to_jack () /* re-establish connections */ for (i = p->begin(); i != p->end(); ++i) { - (*i)->reconnect (); + i->second->reconnect (); } MIDI::Manager::instance()->reconnect (); @@ -1440,21 +1481,14 @@ 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 () -{ - GET_PRIVATE_JACK_POINTER (_jack); - jack_recompute_total_latencies (_priv_jack); + 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; @@ -1475,7 +1509,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; @@ -1490,6 +1524,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 { @@ -1503,10 +1548,10 @@ AudioEngine::create_process_thread (boost::function f, pthread_t* thread GET_PRIVATE_JACK_POINTER_RET (_jack, 0); ThreadData* td = new ThreadData (this, f, stacksize); - if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack), + if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack), jack_is_realtime (_priv_jack), _start_process_thread, td)) { return -1; - } + } return 0; } @@ -1522,3 +1567,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; +}