X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fport_manager.cc;h=f2f2334c273d59720f632044848c857ec76c0a18;hb=dd07428c48bb4df60b9d0c6c3cd524279ab4e524;hp=5c807a6979363d5bee49bbfc7dba66767909d0aa;hpb=df59a000b79f891f17ec8a05b390982dac67e5ff;p=ardour.git diff --git a/libs/ardour/port_manager.cc b/libs/ardour/port_manager.cc index 5c807a6979..f2f2334c27 100644 --- a/libs/ardour/port_manager.cc +++ b/libs/ardour/port_manager.cc @@ -19,11 +19,13 @@ #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 "i18n.h" @@ -67,13 +69,13 @@ PortManager::remove_all_ports () string PortManager::make_port_name_relative (const string& portname) const { - if (!_impl) { + if (!_backend) { return portname; } string::size_type len; string::size_type n; - string self = _impl->my_name(); + string self = _backend->my_name(); len = portname.length(); @@ -99,21 +101,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 { - if (!_impl) { + if (!_backend) { return true; } - string self = _impl->my_name(); + string self = _backend->my_name(); if (portname.find_first_of (':') != string::npos) { if (portname.substr (0, self.length ()) != self) { @@ -127,54 +146,54 @@ PortManager::port_is_mine (const string& portname) const bool PortManager::port_is_physical (const std::string& portname) const { - if (!_impl) { + if (!_backend) { return false; } - PortEngine::PortHandle ph = _impl->get_port_by_name (portname); + 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) { - if (!_impl) { + if (!_backend) { return; } - _impl->get_physical_outputs (type, s); + _backend->get_physical_outputs (type, s); } void PortManager::get_physical_inputs (DataType type, std::vector& s) { - if (!_impl) { + if (!_backend) { return; } - _impl->get_physical_inputs (type, s); + _backend->get_physical_inputs (type, s); } ChanCount PortManager::n_physical_outputs () const { - if (!_impl) { + if (!_backend) { return ChanCount::ZERO; } - return _impl->n_physical_outputs (); + return _backend->n_physical_outputs (); } ChanCount PortManager::n_physical_inputs () const { - if (!_impl) { + if (!_backend) { return ChanCount::ZERO; } - return _impl->n_physical_inputs (); + return _backend->n_physical_inputs (); } /** @param name Full or short name of port @@ -184,7 +203,7 @@ PortManager::n_physical_inputs () const boost::shared_ptr PortManager::get_port_by_name (const string& portname) { - if (!_impl) { + if (!_backend) { return boost::shared_ptr(); } @@ -203,7 +222,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); } @@ -227,29 +246,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) { - if (!_impl) { + s.clear(); + + if (!_backend) { return 0; } - return _impl->get_ports (port_name_pattern, type, flags, s); + return _backend->get_ports (port_name_pattern, type, flags, s); } void PortManager::port_registration_failure (const std::string& portname) { - if (!_impl) { + if (!_backend) { return; } - string full_portname = _impl->my_name(); + 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) { @@ -262,15 +295,25 @@ 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) { boost::shared_ptr newport; try { if (dtype == DataType::AUDIO) { + DEBUG_TRACE (DEBUG::Ports, string_compose ("registering AUDIO port %1, input %2\n", + portname, input)); newport.reset (new AudioPort (portname, (input ? IsInput : IsOutput))); } 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, (input ? IsInput : IsOutput))); + } else { + DEBUG_TRACE (DEBUG::Ports, string_compose ("registering MIDI port %1, input %2\n", + portname, input)); + newport.reset (new MidiPort (portname, (input ? IsInput : IsOutput))); + } } else { throw PortRegistrationFailure("unable to create port (unknown type)"); } @@ -281,7 +324,6 @@ PortManager::register_port (DataType dtype, const string& portname, bool input) /* writer goes out of scope, forces update */ - return newport; } catch (PortRegistrationFailure& err) { @@ -292,18 +334,21 @@ 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) { - return register_port (type, portname, true); + return register_port (type, portname, true, async); } boost::shared_ptr -PortManager::register_output_port (DataType type, const string& portname) +PortManager::register_output_port (DataType type, const string& portname, bool async) { - return register_port (type, portname, false); + return register_port (type, portname, false, async); } int @@ -331,17 +376,17 @@ PortManager::unregister_port (boost::shared_ptr port) bool PortManager::connected (const string& port_name) { - if (!_impl) { + if (!_backend) { return false; } - PortEngine::PortHandle handle = _impl->get_port_by_name (port_name); + PortEngine::PortHandle handle = _backend->get_port_by_name (port_name); if (!handle) { return false; } - return _impl->connected (handle); + return _backend->connected (handle); } int @@ -360,8 +405,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) { @@ -387,12 +437,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; } @@ -410,8 +465,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; } } @@ -422,8 +481,6 @@ PortManager::reestablish_ports () return -1; } - MIDI::Manager::instance()->reestablish (); - return 0; } @@ -433,13 +490,13 @@ PortManager::reconnect_ports () boost::shared_ptr p = ports.reader (); /* re-establish connections */ - + + DEBUG_TRACE (DEBUG::Ports, string_compose ("reconnect %1 ports\n", p->size())); + for (Ports::iterator i = p->begin(); i != p->end(); ++i) { i->second->reconnect (); } - MIDI::Manager::instance()->reconnect (); - return 0; } @@ -479,59 +536,59 @@ PortManager::registration_callback () bool PortManager::can_request_input_monitoring () const { - if (!_impl) { + if (!_backend) { return false; } - return _impl->can_monitor_input (); + return _backend->can_monitor_input (); } void PortManager::request_input_monitoring (const string& name, bool yn) const { - if (!_impl) { + if (!_backend) { return; } - PortEngine::PortHandle ph = _impl->get_port_by_name (name); + 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 { - if (!_impl) { + if (!_backend) { return; } - PortEngine::PortHandle ph = _impl->get_port_by_name (name); + 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 (!_impl) { + if (!_backend) { return 0; } - return _impl->port_name_size (); + return _backend->port_name_size (); } string PortManager::my_name() const { - if (!_impl) { + if (!_backend) { return string(); } - return _impl->my_name(); + return _backend->my_name(); } int @@ -543,3 +600,126 @@ PortManager::graph_order_callback () 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) +{ + for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) { + 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; +}