X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fport_manager.cc;h=408e7804603eb73961284584529f3ee63f08fd7b;hb=6946bdc0830c9f0971d2cd0d54b27e343c54d96a;hp=b5f280292e4fc785718ac13d8616be5b3418ff2e;hpb=682ebad62bdc85df151ad0b81dc27cc9f3e71cec;p=ardour.git diff --git a/libs/ardour/port_manager.cc b/libs/ardour/port_manager.cc index b5f280292e..408e780460 100644 --- a/libs/ardour/port_manager.cc +++ b/libs/ardour/port_manager.cc @@ -17,15 +17,27 @@ */ +#ifdef COMPILER_MSVC +#include // Microsoft's nearest equivalent to +#include +#else +#include +#endif + +#include "pbd/convert.h" #include "pbd/error.h" -#include "midi++/manager.h" - -#include "ardour/port_manager.h" +#include "ardour/async_midi_port.h" +#include "ardour/audio_backend.h" #include "ardour/audio_port.h" +#include "ardour/debug.h" #include "ardour/midi_port.h" +#include "ardour/midiport_manager.h" +#include "ardour/port_manager.h" +#include "ardour/profile.h" +#include "ardour/session.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace ARDOUR; using namespace PBD; @@ -67,20 +79,18 @@ PortManager::remove_all_ports () string PortManager::make_port_name_relative (const string& portname) const { - string::size_type len; - string::size_type n; - string self = _impl->my_name(); + if (!_backend) { + return portname; + } - len = portname.length(); + string::size_type colon = portname.find (':'); - for (n = 0; n < len; ++n) { - if (portname[n] == ':') { - break; - } + if (colon == string::npos) { + return portname; } - if ((n != len) && (portname.substr (0, n) == self)) { - return portname.substr (n+1); + if (portname.substr (0, colon) == _backend->my_name()) { + return portname.substr (colon+1); } return portname; @@ -95,17 +105,38 @@ PortManager::make_port_name_non_relative (const string& portname) const return portname; } - str = _impl->my_name(); + str = _backend->my_name(); str += ':'; str += portname; return str; } +std::string +PortManager::get_pretty_name_by_name(const std::string& portname) const +{ + PortEngine::PortHandle ph = _backend->get_port_by_name (portname); + if (ph) { + std::string value; + std::string type; + if (0 == _backend->get_port_property (ph, + "http://jackaudio.org/metadata/pretty-name", + value, type)) + { + return value; + } + } + return ""; +} + bool PortManager::port_is_mine (const string& portname) const { - string self = _impl->my_name(); + if (!_backend) { + return true; + } + + string self = _backend->my_name(); if (portname.find_first_of (':') != string::npos) { if (portname.substr (0, self.length ()) != self) { @@ -119,36 +150,56 @@ PortManager::port_is_mine (const string& portname) const bool PortManager::port_is_physical (const std::string& portname) const { - PortEngine::PortHandle ph = _impl->get_port_by_name (portname); + if (!_backend) { + return false; + } + + PortEngine::PortHandle ph = _backend->get_port_by_name (portname); if (!ph) { return false; } - return _impl->port_is_physical (ph); + return _backend->port_is_physical (ph); } void PortManager::get_physical_outputs (DataType type, std::vector& s) { - _impl->get_physical_outputs (type, s); + if (!_backend) { + s.clear (); + return; + } + _backend->get_physical_outputs (type, s); } - + void PortManager::get_physical_inputs (DataType type, std::vector& s) { - _impl->get_physical_inputs (type, s); + if (!_backend) { + s.clear (); + return; + } + + _backend->get_physical_inputs (type, s); } - + ChanCount PortManager::n_physical_outputs () const { - return _impl->n_physical_outputs (); + if (!_backend) { + return ChanCount::ZERO; + } + + return _backend->n_physical_outputs (); } - + ChanCount PortManager::n_physical_inputs () const { - return _impl->n_physical_inputs (); + if (!_backend) { + return ChanCount::ZERO; + } + return _backend->n_physical_inputs (); } /** @param name Full or short name of port @@ -158,6 +209,10 @@ PortManager::n_physical_inputs () const boost::shared_ptr PortManager::get_port_by_name (const string& portname) { + if (!_backend) { + return boost::shared_ptr(); + } + if (!port_is_mine (portname)) { /* not an ardour port */ return boost::shared_ptr (); @@ -173,7 +228,7 @@ PortManager::get_port_by_name (const string& portname) 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 (_impl->get_port_name (x->second->port_handle())); + const std::string check = make_port_name_relative (_backend->get_port_name (x->second->port_handle())); if (check != rel) { x->second->set_name (check); } @@ -189,7 +244,7 @@ PortManager::port_renamed (const std::string& old_relative_name, const std::stri 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); @@ -197,21 +252,43 @@ PortManager::port_renamed (const std::string& old_relative_name, const std::stri } } +int +PortManager::get_ports (DataType type, PortList& pl) +{ + boost::shared_ptr plist = ports.reader(); + for (Ports::iterator p = plist->begin(); p != plist->end(); ++p) { + if (p->second->type() == type) { + pl.push_back (p->second); + } + } + return pl.size(); +} + int PortManager::get_ports (const string& port_name_pattern, DataType type, PortFlags flags, vector& s) { - return _impl->get_ports (port_name_pattern, type, flags, s); + s.clear(); + + if (!_backend) { + return 0; + } + + return _backend->get_ports (port_name_pattern, type, flags, s); } void PortManager::port_registration_failure (const std::string& portname) { - string full_portname = _impl->my_name(); + if (!_backend) { + return; + } + + string full_portname = _backend->my_name(); full_portname += ':'; full_portname += portname; - PortEngine::PortHandle p = _impl->get_port_by_name (full_portname); + PortEngine::PortHandle p = _backend->get_port_by_name (full_portname); string reason; if (p) { @@ -224,15 +301,29 @@ PortManager::port_registration_failure (const std::string& portname) } boost::shared_ptr -PortManager::register_port (DataType dtype, const string& portname, bool input) +PortManager::register_port (DataType dtype, const string& portname, bool input, bool async, PortFlags flags) { boost::shared_ptr newport; + /* limit the possible flags that can be set */ + + flags = PortFlags (flags & (Hidden|Shadow|IsTerminal)); + try { if (dtype == DataType::AUDIO) { - newport.reset (new AudioPort (portname, (input ? IsInput : IsOutput))); + DEBUG_TRACE (DEBUG::Ports, string_compose ("registering AUDIO port %1, input %2\n", + portname, input)); + newport.reset (new AudioPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags))); } else if (dtype == DataType::MIDI) { - newport.reset (new MidiPort (portname, (input ? IsInput : IsOutput))); + if (async) { + DEBUG_TRACE (DEBUG::Ports, string_compose ("registering ASYNC MIDI port %1, input %2\n", + portname, input)); + newport.reset (new AsyncMIDIPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags))); + } else { + DEBUG_TRACE (DEBUG::Ports, string_compose ("registering MIDI port %1, input %2\n", + portname, input)); + newport.reset (new MidiPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags))); + } } else { throw PortRegistrationFailure("unable to create port (unknown type)"); } @@ -243,7 +334,6 @@ PortManager::register_port (DataType dtype, const string& portname, bool input) /* writer goes out of scope, forces update */ - return newport; } catch (PortRegistrationFailure& err) { @@ -254,23 +344,32 @@ PortManager::register_port (DataType dtype, const string& portname, bool input) } catch (...) { throw PortRegistrationFailure("unable to create port (unknown error)"); } + + DEBUG_TRACE (DEBUG::Ports, string_compose ("\t%2 port registration success, ports now = %1\n", ports.reader()->size(), this)); + return newport; } boost::shared_ptr -PortManager::register_input_port (DataType type, const string& portname) +PortManager::register_input_port (DataType type, const string& portname, bool async, PortFlags extra_flags) { - return register_port (type, portname, true); + return register_port (type, portname, true, async, extra_flags); } boost::shared_ptr -PortManager::register_output_port (DataType type, const string& portname) +PortManager::register_output_port (DataType type, const string& portname, bool async, PortFlags extra_flags) { - return register_port (type, portname, false); + return register_port (type, portname, false, async, extra_flags); } int PortManager::unregister_port (boost::shared_ptr port) { + /* This is a little subtle. We do not call the backend's port + * unregistration code from here. That is left for the Port + * destructor. We are trying to drop references to the Port object + * here, so that its destructor will run and it will unregister itself. + */ + /* caller must hold process lock */ { @@ -293,13 +392,51 @@ PortManager::unregister_port (boost::shared_ptr port) bool PortManager::connected (const string& port_name) { - PortEngine::PortHandle handle = _impl->get_port_by_name (port_name); + if (!_backend) { + return false; + } + + PortEngine::PortHandle handle = _backend->get_port_by_name (port_name); + + if (!handle) { + return false; + } + + return _backend->connected (handle); +} + +bool +PortManager::physically_connected (const string& port_name) +{ + if (!_backend) { + return false; + } + + PortEngine::PortHandle handle = _backend->get_port_by_name (port_name); if (!handle) { return false; } - return _impl->connected (handle); + return _backend->physically_connected (handle); +} + +int +PortManager::get_connections (const string& port_name, std::vector& s) +{ + if (!_backend) { + s.clear (); + return 0; + } + + PortEngine::PortHandle handle = _backend->get_port_by_name (port_name); + + if (!handle) { + s.clear (); + return 0; + } + + return _backend->get_connections (handle, s); } int @@ -318,8 +455,13 @@ PortManager::connect (const string& source, const string& destination) } else if (dst) { ret = dst->connect (s); } else { - /* neither port is known to us, and this API isn't intended for use as a general patch bay */ - ret = -1; + /* neither port is known to us ...hand-off to the PortEngine + */ + if (_backend) { + ret = _backend->connect (s, d); + } else { + ret = -1; + } } if (ret > 0) { @@ -345,12 +487,17 @@ PortManager::disconnect (const string& source, const string& destination) boost::shared_ptr dst = get_port_by_name (d); if (src) { - ret = src->disconnect (d); + ret = src->disconnect (d); } else if (dst) { - ret = dst->disconnect (s); + ret = dst->disconnect (s); } else { - /* neither port is known to us, and this API isn't intended for use as a general patch bay */ - ret = -1; + /* neither port is known to us ...hand-off to the PortEngine + */ + if (_backend) { + ret = _backend->disconnect (s, d); + } else { + ret = -1; + } } return ret; } @@ -368,8 +515,12 @@ PortManager::reestablish_ports () boost::shared_ptr p = ports.reader (); + DEBUG_TRACE (DEBUG::Ports, string_compose ("reestablish %1 ports\n", p->size())); + for (i = p->begin(); i != p->end(); ++i) { if (i->second->reestablish ()) { + error << string_compose (_("Re-establising port %1 failed"), i->second->name()) << endmsg; + std::cerr << string_compose (_("Re-establising port %1 failed"), i->second->name()) << std::endl; break; } } @@ -380,8 +531,6 @@ PortManager::reestablish_ports () return -1; } - MIDI::Manager::instance()->reestablish (); - return 0; } @@ -390,13 +539,15 @@ PortManager::reconnect_ports () { boost::shared_ptr p = ports.reader (); - /* re-establish connections */ - - for (Ports::iterator i = p->begin(); i != p->end(); ++i) { - i->second->reconnect (); - } + if (!Profile->get_trx()) { + /* re-establish connections */ + + DEBUG_TRACE (DEBUG::Ports, string_compose ("reconnect %1 ports\n", p->size())); - MIDI::Manager::instance()->reconnect (); + for (Ports::iterator i = p->begin(); i != p->end(); ++i) { + i->second->reconnect (); + } + } return 0; } @@ -424,7 +575,7 @@ PortManager::connect_callback (const string& a, const string& b, bool conn) port_b, b, conn ); /* EMIT SIGNAL */ -} +} void PortManager::registration_callback () @@ -437,26 +588,235 @@ PortManager::registration_callback () bool PortManager::can_request_input_monitoring () const { - return _impl->can_monitor_input (); + if (!_backend) { + return false; + } + + return _backend->can_monitor_input (); } - + void PortManager::request_input_monitoring (const string& name, bool yn) const { - PortEngine::PortHandle ph = _impl->get_port_by_name (name); + if (!_backend) { + return; + } + + PortEngine::PortHandle ph = _backend->get_port_by_name (name); if (ph) { - _impl->request_input_monitoring (ph, yn); + _backend->request_input_monitoring (ph, yn); } } - + void PortManager::ensure_input_monitoring (const string& name, bool yn) const { - PortEngine::PortHandle ph = _impl->get_port_by_name (name); + if (!_backend) { + return; + } + + PortEngine::PortHandle ph = _backend->get_port_by_name (name); if (ph) { - _impl->ensure_input_monitoring (ph, yn); + _backend->ensure_input_monitoring (ph, yn); + } +} + +uint32_t +PortManager::port_name_size() const +{ + if (!_backend) { + return 0; + } + + return _backend->port_name_size (); +} + +string +PortManager::my_name() const +{ + if (!_backend) { + return string(); + } + + return _backend->my_name(); +} + +int +PortManager::graph_order_callback () +{ + if (!_port_remove_in_progress) { + GraphReordered(); /* EMIT SIGNAL */ + } + + return 0; +} + +void +PortManager::cycle_start (pframes_t nframes) +{ + Port::set_global_port_buffer_offset (0); + Port::set_cycle_framecnt (nframes); + + _cycle_ports = ports.reader (); + + for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) { + p->second->cycle_start (nframes); + } +} + +void +PortManager::cycle_end (pframes_t nframes) +{ + for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) { + p->second->cycle_end (nframes); + } + + for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) { + p->second->flush_buffers (nframes); + } + + _cycle_ports.reset (); + + /* we are done */ +} + +void +PortManager::silence (pframes_t nframes, Session *s) +{ + for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) { + if (s && i->second == s->mtc_output_port ()) { + continue; + } + if (s && i->second == s->midi_clock_output_port ()) { + continue; + } + if (s && i->second == s->ltc_output_port ()) { + continue; + } + if (boost::dynamic_pointer_cast(i->second)) { + continue; + } + if (i->second->sends_output()) { + i->second->get_buffer(nframes).silence(nframes); + } + } +} + +void +PortManager::silence_outputs (pframes_t nframes) +{ + std::vector port_names; + if (get_ports("", DataType::AUDIO, IsOutput, port_names)) { + for (std::vector::iterator p = port_names.begin(); p != port_names.end(); ++p) { + if (!port_is_mine(*p)) { + continue; + } + PortEngine::PortHandle ph = _backend->get_port_by_name (*p); + if (!ph) { + continue; + } + void *buf = _backend->get_buffer(ph, nframes); + if (!buf) { + continue; + } + memset (buf, 0, sizeof(float) * nframes); + } + } + + if (get_ports("", DataType::MIDI, IsOutput, port_names)) { + for (std::vector::iterator p = port_names.begin(); p != port_names.end(); ++p) { + if (!port_is_mine(*p)) { + continue; + } + PortEngine::PortHandle ph = _backend->get_port_by_name (*p); + if (!ph) { + continue; + } + void *buf = _backend->get_buffer(ph, nframes); + if (!buf) { + continue; + } + _backend->midi_clear (buf); + } } } +void +PortManager::check_monitoring () +{ + for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) { + + bool x; + + if (i->second->last_monitor() != (x = i->second->monitoring_input ())) { + i->second->set_last_monitor (x); + /* XXX I think this is dangerous, due to + a likely mutex in the signal handlers ... + */ + i->second->MonitorInputChanged (x); /* EMIT SIGNAL */ + } + } +} + +void +PortManager::fade_out (gain_t base_gain, gain_t gain_step, pframes_t nframes) +{ + for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) { + + 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 = base_gain; + + for (pframes_t n = 0; n < nframes; ++n) { + *s++ *= g; + g -= gain_step; + } + } + } + } +} + +PortEngine& +PortManager::port_engine() +{ + assert (_backend); + return *_backend; +} + +bool +PortManager::port_is_control_only (std::string const& name) +{ + static regex_t compiled_pattern; + static string pattern; + + if (pattern.empty()) { + + /* This is a list of regular expressions that match ports + * related to physical MIDI devices that we do not want to + * expose as normal physical ports. + */ + + const char * const control_only_ports[] = { + X_(".*Ableton Push.*"), + X_(".*FaderPort .*"), + }; + + pattern = "("; + for (size_t n = 0; n < sizeof (control_only_ports)/sizeof (control_only_ports[0]); ++n) { + if (n > 0) { + pattern += '|'; + } + pattern += control_only_ports[n]; + } + pattern += ')'; + + regcomp (&compiled_pattern, pattern.c_str(), REG_EXTENDED|REG_NOSUB); + } + + return regexec (&compiled_pattern, name.c_str(), 0, 0, 0) == 0; +}