+
+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 .*"),
+ X_(".*FaderPort8 .*"),
+ X_(".*FaderPort16 .*"),
+ X_(".*FaderPort2 .*"),
+ X_(".*US-2400 .*"),
+ X_(".*Mackie .*"),
+ };
+
+ 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;
+}
+
+PortManager::MidiPortInformation
+PortManager::midi_port_information (std::string const & name)
+{
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+
+ fill_midi_port_info_locked ();
+
+ MidiPortInfo::iterator x = midi_port_info.find (name);
+
+ if (x != midi_port_info.end()) {
+ return x->second;
+ }
+
+ return MidiPortInformation ();
+}
+
+void
+PortManager::get_known_midi_ports (vector<string>& copy)
+{
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+
+ fill_midi_port_info_locked ();
+
+ for (MidiPortInfo::const_iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
+ copy.push_back (x->first);
+ }
+}
+
+void
+PortManager::get_midi_selection_ports (vector<string>& copy)
+{
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+
+ fill_midi_port_info_locked ();
+
+ for (MidiPortInfo::const_iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
+ if (x->second.properties & MidiPortSelection) {
+ copy.push_back (x->first);
+ }
+ }
+}
+
+void
+PortManager::set_port_pretty_name (string const & port, string const & pretty)
+{
+ {
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+
+ fill_midi_port_info_locked ();
+
+ MidiPortInfo::iterator x = midi_port_info.find (port);
+ if (x == midi_port_info.end()) {
+ return;
+ }
+ x->second.pretty_name = pretty;
+ }
+
+ /* push into back end */
+
+ PortEngine::PortHandle ph = _backend->get_port_by_name (port);
+
+ if (ph) {
+ _backend->set_port_property (ph, "http://jackaudio.org/metadata/pretty-name", pretty, string());
+ }
+
+ save_midi_port_info ();
+ MidiPortInfoChanged (); /* EMIT SIGNAL*/
+}
+
+void
+PortManager::add_midi_port_flags (string const & port, MidiPortFlags flags)
+{
+ bool emit = false;
+
+ {
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+
+ fill_midi_port_info_locked ();
+
+ MidiPortInfo::iterator x = midi_port_info.find (port);
+
+ if (x != midi_port_info.end()) {
+ if ((x->second.properties & flags) != flags) { // at least one missing
+ x->second.properties = MidiPortFlags (x->second.properties | flags);
+ emit = true;
+ }
+ }
+ }
+
+ if (emit) {
+ if (flags & MidiPortSelection) {
+ MidiSelectionPortsChanged (); /* EMIT SIGNAL */
+ }
+
+ if (flags != MidiPortSelection) {
+ MidiPortInfoChanged (); /* EMIT SIGNAL */
+ }
+
+ save_midi_port_info ();
+ }
+}
+
+void
+PortManager::remove_midi_port_flags (string const & port, MidiPortFlags flags)
+{
+ bool emit = false;
+
+ {
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+
+ fill_midi_port_info_locked ();
+
+ MidiPortInfo::iterator x = midi_port_info.find (port);
+
+ if (x != midi_port_info.end()) {
+ if (x->second.properties & flags) { // at least one is set
+ x->second.properties = MidiPortFlags (x->second.properties & ~flags);
+ emit = true;
+ }
+ }
+ }
+
+ if (emit) {
+ if (flags & MidiPortSelection) {
+ MidiSelectionPortsChanged (); /* EMIT SIGNAL */
+ }
+
+ if (flags != MidiPortSelection) {
+ MidiPortInfoChanged (); /* EMIT SIGNAL */
+ }
+
+ save_midi_port_info ();
+ }
+}
+
+string
+PortManager::midi_port_info_file ()
+{
+ return Glib::build_filename (user_config_directory(), X_("midi_port_info"));
+}
+
+void
+PortManager::save_midi_port_info ()
+{
+ string path = midi_port_info_file ();
+
+ XMLNode* root = new XMLNode (X_("MidiPortInfo"));
+
+ {
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+
+ if (midi_port_info.empty()) {
+ delete root;
+ return;
+ }
+
+ for (MidiPortInfo::iterator i = midi_port_info.begin(); i != midi_port_info.end(); ++i) {
+ XMLNode* node = new XMLNode (X_("port"));
+ node->set_property (X_("name"), i->first);
+ node->set_property (X_("backend"), i->second.backend);
+ node->set_property (X_("pretty-name"), i->second.pretty_name);
+ node->set_property (X_("input"), i->second.input);
+ node->set_property (X_("properties"), i->second.properties);
+ root->add_child_nocopy (*node);
+ }
+ }
+
+ XMLTree tree;
+
+ tree.set_root (root);
+
+ if (!tree.write (path)) {
+ error << string_compose (_("Could not save MIDI port info to %1"), path) << endmsg;
+ }
+}
+
+void
+PortManager::load_midi_port_info ()
+{
+ string path = midi_port_info_file ();
+ XMLTree tree;
+
+ if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
+ return;
+ }
+
+ if (!tree.read (path)) {
+ error << string_compose (_("Cannot load MIDI port info from %1"), path) << endmsg;
+ return;
+ }
+
+ midi_port_info.clear ();
+
+ for (XMLNodeConstIterator i = tree.root()->children().begin(); i != tree.root()->children().end(); ++i) {
+ string name;
+ string backend;
+ string pretty;
+ bool input;
+ MidiPortFlags properties;
+
+
+ if (!(*i)->get_property (X_("name"), name) ||
+ !(*i)->get_property (X_("backend"), backend) ||
+ !(*i)->get_property (X_("pretty-name"), pretty) ||
+ !(*i)->get_property (X_("input"), input) ||
+ !(*i)->get_property (X_("properties"), properties)) {
+ /* should only affect version changes */
+ error << string_compose (_("MIDI port info file %1 contains invalid information - please remove it."), path) << endmsg;
+ continue;
+ }
+
+ MidiPortInformation mpi (backend, pretty, input, properties, false);
+
+ midi_port_info.insert (make_pair (name, mpi));
+ }
+}
+
+void
+PortManager::fill_midi_port_info ()
+{
+ {
+ Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
+ fill_midi_port_info_locked ();
+ }
+}
+
+string
+PortManager::short_port_name_from_port_name (std::string const & full_name) const
+{
+ string::size_type colon = full_name.find_first_of (':');
+ if (colon == string::npos || colon == full_name.length()) {
+ return full_name;
+ }
+ return full_name.substr (colon+1);
+}
+
+void
+PortManager::fill_midi_port_info_locked ()
+{
+ /* MIDI info mutex MUST be held */
+
+ if (!midi_info_dirty || !_backend) {
+ return;
+ }
+
+ std::vector<string> ports;
+
+ AudioEngine::instance()->get_ports (string(), DataType::MIDI, IsOutput, ports);
+
+ for (vector<string>::iterator p = ports.begin(); p != ports.end(); ++p) {
+
+ /* ugly hack, ideally we'd use a port-flag, or at vkbd_output_port()->name() */
+ if (port_is_mine (*p) && *p != _backend->my_name() + ":" + _("Virtual Keyboard")) {
+ continue;
+ }
+
+ if (midi_port_info.find (*p) == midi_port_info.end()) {
+
+ MidiPortFlags flags (MidiPortFlags (0));
+
+ if (port_is_control_only (*p)) {
+ flags = MidiPortControl;
+ } else if (*p == _backend->my_name() + ":" + _("Virtual Keyboard")) {
+ flags = MidiPortFlags(MidiPortSelection | MidiPortMusic);
+ }
+
+ MidiPortInformation mpi (_backend->name(), *p, true, flags, true);
+
+#ifdef LINUX
+ if ((*p.find (X_("Midi Through")) != string::npos || (*p).find (X_("Midi-Through")) != string::npos)) {
+ mpi.properties = MidiPortFlags (mpi.properties | MidiPortVirtual);
+ }
+#endif
+ midi_port_info.insert (make_pair (*p, mpi));
+ }
+ }
+
+ AudioEngine::instance()->get_ports (string(), DataType::MIDI, IsInput, ports);
+
+ for (vector<string>::iterator p = ports.begin(); p != ports.end(); ++p) {
+
+ if (port_is_mine (*p)) {
+ continue;
+ }
+
+ if (midi_port_info.find (*p) == midi_port_info.end()) {
+
+ MidiPortFlags flags (MidiPortFlags (0));
+
+ if (port_is_control_only (*p)) {
+ flags = MidiPortControl;
+ }
+
+ MidiPortInformation mpi (_backend->name(), *p, false, flags, true);
+
+#ifdef LINUX
+ if ((*p.find (X_("Midi Through")) != string::npos || (*p).find (X_("Midi-Through")) != string::npos)) {
+ mpi.properties = MidiPortFlags (mpi.properties | MidiPortVirtual);
+ }
+#endif
+ midi_port_info.insert (make_pair (*p, mpi));
+ }
+ }
+
+ /* now check with backend about which ports are present and pull
+ * pretty-name if it exists
+ */
+
+ for (MidiPortInfo::iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
+
+ if (x->second.backend != _backend->name()) {
+ /* this port (info) comes from a different
+ * backend. While there's a reasonable chance that it
+ * refers to the same physical (or virtual) endpoint, we
+ * don't allow its use with this backend.
+ */
+ x->second.exists = false;
+ continue;
+ }
+
+ PortEngine::PortHandle ph = _backend->get_port_by_name (x->first);
+
+ if (!ph) {
+ /* port info saved from some condition where this port
+ * existed, but no longer does (i.e. device unplugged
+ * at present). We don't remove it from midi_port_info.
+ */
+ x->second.exists = false;
+
+ } else {
+ x->second.exists = true;
+
+ /* check with backend for pre-existing pretty name */
+
+ string value = AudioEngine::instance()->get_pretty_name_by_name (x->first);
+
+ if (!value.empty()) {
+ x->second.pretty_name = value;
+ }
+ }
+ }
+
+ midi_info_dirty = false;
+}
+
+void
+PortManager::set_port_buffer_sizes (pframes_t n)
+{
+
+ boost::shared_ptr<Ports> all = ports.reader();
+
+ for (Ports::iterator p = all->begin(); p != all->end(); ++p) {
+ p->second->set_buffer_size (n);
+ }
+}