libs/ardour/port_manager.cc

   1 /*
   2  * Copyright (C) 2013-2019 Paul Davis <paul@linuxaudiosystems.com>
   3  * Copyright (C) 2015-2019 Robin Gareus <robin@gareus.org>
   4  * Copyright (C) 2017-2018 Ben Loftis <ben@harrisonconsoles.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <vector>
  22
  23 #ifdef COMPILER_MSVC
  24 #include <io.h> // Microsoft's nearest equivalent to <unistd.h>
  25 #include <ardourext/misc.h>
  26 #else
  27 #include <regex.h>
  28 #endif
  29
  30 #include <glibmm/fileutils.h>
  31 #include <glibmm/miscutils.h>
  32
  33 #include "pbd/error.h"
  34 #include "pbd/strsplit.h"
  35
  36 #include "ardour/async_midi_port.h"
  37 #include "ardour/audio_backend.h"
  38 #include "ardour/audio_port.h"
  39 #include "ardour/debug.h"
  40 #include "ardour/filesystem_paths.h"
  41 #include "ardour/midi_port.h"
  42 #include "ardour/midiport_manager.h"
  43 #include "ardour/port_manager.h"
  44 #include "ardour/profile.h"
  45 #include "ardour/rt_tasklist.h"
  46 #include "ardour/session.h"
  47 #include "ardour/types_convert.h"
  48
  49 #include "pbd/i18n.h"
  50
  51 using namespace ARDOUR;
  52 using namespace PBD;
  53 using std::string;
  54 using std::vector;
  55
  56 PortManager::PortManager ()
  57         : ports (new Ports)
  58         , _port_remove_in_progress (false)
  59         , _port_deletions_pending (8192) /* ick, arbitrary sizing */
  60         , midi_info_dirty (true)
  61 {
  62         load_midi_port_info ();
  63 }
  64
  65 void
  66 PortManager::clear_pending_port_deletions ()
  67 {
  68         Port* p;
  69
  70         DEBUG_TRACE (DEBUG::Ports, string_compose ("pending port deletions: %1\n", _port_deletions_pending.read_space()));
  71
  72         while (_port_deletions_pending.read (&p, 1) == 1) {
  73                 delete p;
  74         }
  75 }
  76
  77 void
  78 PortManager::remove_all_ports ()
  79 {
  80         /* make sure that JACK callbacks that will be invoked as we cleanup
  81          * ports know that they have nothing to do.
  82          */
  83
  84         _port_remove_in_progress = true;
  85
  86         /* process lock MUST be held by caller
  87         */
  88
  89         {
  90                 RCUWriter<Ports> writer (ports);
  91                 boost::shared_ptr<Ports> ps = writer.get_copy ();
  92                 ps->clear ();
  93         }
  94
  95         /* clear dead wood list in RCU */
  96
  97         ports.flush ();
  98
  99         /* clear out pending port deletion list. we know this is safe because
 100          * the auto connect thread in Session is already dead when this is
 101          * done. It doesn't use shared_ptr<Port> anyway.
 102          */
 103
 104         _port_deletions_pending.reset ();
 105
 106         _port_remove_in_progress = false;
 107 }
 108
 109
 110 string
 111 PortManager::make_port_name_relative (const string& portname) const
 112 {
 113         if (!_backend) {
 114                 return portname;
 115         }
 116
 117         string::size_type colon = portname.find (':');
 118
 119         if (colon == string::npos) {
 120                 return portname;
 121         }
 122
 123         if (portname.substr (0, colon) == _backend->my_name()) {
 124                 return portname.substr (colon+1);
 125         }
 126
 127         return portname;
 128 }
 129
 130 string
 131 PortManager::make_port_name_non_relative (const string& portname) const
 132 {
 133         string str;
 134
 135         if (portname.find_first_of (':') != string::npos) {
 136                 return portname;
 137         }
 138
 139         str  = _backend->my_name();
 140         str += ':';
 141         str += portname;
 142
 143         return str;
 144 }
 145
 146 std::string
 147 PortManager::get_pretty_name_by_name(const std::string& portname) const
 148 {
 149         PortEngine::PortHandle ph = _backend->get_port_by_name (portname);
 150
 151         if (ph) {
 152                 std::string value;
 153                 std::string type;
 154                 if (0 == _backend->get_port_property (ph, "http://jackaudio.org/metadata/pretty-name", value, type)) {
 155                         return value;
 156                 }
 157         }
 158
 159         return string();
 160 }
 161
 162 bool
 163 PortManager::port_is_mine (const string& portname) const
 164 {
 165         if (!_backend) {
 166                 return true;
 167         }
 168
 169         string self = _backend->my_name();
 170
 171         if (portname.find_first_of (':') != string::npos) {
 172                 if (portname.substr (0, self.length ()) != self) {
 173                         return false;
 174                 }
 175         }
 176
 177         return true;
 178 }
 179
 180 bool
 181 PortManager::port_is_physical (const std::string& portname) const
 182 {
 183         if (!_backend) {
 184                 return false;
 185         }
 186
 187         PortEngine::PortHandle ph = _backend->get_port_by_name (portname);
 188         if (!ph) {
 189                 return false;
 190         }
 191
 192         return _backend->port_is_physical (ph);
 193 }
 194
 195 void
 196 PortManager::filter_midi_ports (vector<string>& ports, MidiPortFlags include, MidiPortFlags exclude)
 197 {
 198
 199         if (!include && !exclude) {
 200                 return;
 201         }
 202
 203         {
 204                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
 205
 206                 fill_midi_port_info_locked ();
 207
 208                 for (vector<string>::iterator si = ports.begin(); si != ports.end(); ) {
 209
 210                         MidiPortInfo::iterator x = midi_port_info.find (*si);
 211
 212                         if (x == midi_port_info.end()) {
 213                                 ++si;
 214                                 continue;
 215                         }
 216
 217                         MidiPortInformation& mpi (x->second);
 218
 219                         if (mpi.pretty_name.empty()) {
 220                                 /* no information !!! */
 221                                 ++si;
 222                                 continue;
 223                         }
 224
 225                         if (include) {
 226                                 if ((mpi.properties & include) != include) {
 227                                         /* properties do not include requested ones */
 228                                         si = ports.erase (si);
 229                                         continue;
 230                                 }
 231                         }
 232
 233                         if (exclude) {
 234                                 if ((mpi.properties & exclude)) {
 235                                         /* properties include ones to avoid */
 236                                         si = ports.erase (si);
 237                                         continue;
 238                                 }
 239                         }
 240
 241                         ++si;
 242                 }
 243         }
 244 }
 245
 246 void
 247 PortManager::get_physical_outputs (DataType type, std::vector<std::string>& s, MidiPortFlags include, MidiPortFlags exclude)
 248 {
 249         if (!_backend) {
 250                 s.clear ();
 251                 return;
 252         }
 253         _backend->get_physical_outputs (type, s);
 254         filter_midi_ports (s, include, exclude);
 255 }
 256
 257 void
 258 PortManager::get_physical_inputs (DataType type, std::vector<std::string>& s, MidiPortFlags include, MidiPortFlags exclude)
 259 {
 260         if (!_backend) {
 261                 s.clear ();
 262                 return;
 263         }
 264
 265         _backend->get_physical_inputs (type, s);
 266         filter_midi_ports (s, include, exclude);
 267 }
 268
 269 ChanCount
 270 PortManager::n_physical_outputs () const
 271 {
 272         if (!_backend) {
 273                 return ChanCount::ZERO;
 274         }
 275
 276         return _backend->n_physical_outputs ();
 277 }
 278
 279 ChanCount
 280 PortManager::n_physical_inputs () const
 281 {
 282         if (!_backend) {
 283                 return ChanCount::ZERO;
 284         }
 285         return _backend->n_physical_inputs ();
 286 }
 287
 288 /** @param name Full or short name of port
 289  *  @return Corresponding Port or 0.
 290  */
 291 boost::shared_ptr<Port>
 292 PortManager::get_port_by_name (const string& portname)
 293 {
 294         if (!_backend) {
 295                 return boost::shared_ptr<Port>();
 296         }
 297
 298         if (!port_is_mine (portname)) {
 299                 /* not an ardour port */
 300                 return boost::shared_ptr<Port> ();
 301         }
 302
 303         boost::shared_ptr<Ports> pr = ports.reader();
 304         std::string rel = make_port_name_relative (portname);
 305         Ports::iterator x = pr->find (rel);
 306
 307         if (x != pr->end()) {
 308                 /* its possible that the port was renamed by some 3rd party and
 309                  * we don't know about it. check for this (the check is quick
 310                  * and cheap), and if so, rename the port (which will alter
 311                  * the port map as a side effect).
 312                  */
 313                 const std::string check = make_port_name_relative (_backend->get_port_name (x->second->port_handle()));
 314                 if (check != rel) {
 315                         x->second->set_name (check);
 316                 }
 317                 return x->second;
 318         }
 319
 320         return boost::shared_ptr<Port> ();
 321 }
 322
 323 void
 324 PortManager::port_renamed (const std::string& old_relative_name, const std::string& new_relative_name)
 325 {
 326         RCUWriter<Ports> writer (ports);
 327         boost::shared_ptr<Ports> p = writer.get_copy();
 328         Ports::iterator x = p->find (old_relative_name);
 329
 330         if (x != p->end()) {
 331                 boost::shared_ptr<Port> port = x->second;
 332                 p->erase (x);
 333                 p->insert (make_pair (new_relative_name, port));
 334         }
 335 }
 336
 337 int
 338 PortManager::get_ports (DataType type, PortList& pl)
 339 {
 340         boost::shared_ptr<Ports> plist = ports.reader();
 341         for (Ports::iterator p = plist->begin(); p != plist->end(); ++p) {
 342                 if (p->second->type() == type) {
 343                         pl.push_back (p->second);
 344                 }
 345         }
 346         return pl.size();
 347 }
 348
 349 int
 350 PortManager::get_ports (const string& port_name_pattern, DataType type, PortFlags flags, vector<string>& s)
 351 {
 352         s.clear();
 353
 354         if (!_backend) {
 355                 return 0;
 356         }
 357
 358         return _backend->get_ports (port_name_pattern, type, flags, s);
 359 }
 360
 361 void
 362 PortManager::port_registration_failure (const std::string& portname)
 363 {
 364         if (!_backend) {
 365                 return;
 366         }
 367
 368         string full_portname = _backend->my_name();
 369         full_portname += ':';
 370         full_portname += portname;
 371
 372
 373         PortEngine::PortHandle p = _backend->get_port_by_name (full_portname);
 374         string reason;
 375
 376         if (p) {
 377                 reason = string_compose (_("a port with the name \"%1\" already exists: check for duplicated track/bus names"), portname);
 378         } else {
 379                 reason = string_compose (_("No more ports are available. You will need to stop %1 and restart with more ports if you need this many tracks."), PROGRAM_NAME);
 380         }
 381
 382         throw PortRegistrationFailure (string_compose (_("AudioEngine: cannot register port \"%1\": %2"), portname, reason).c_str());
 383 }
 384
 385 struct PortDeleter
 386 {
 387         void operator() (Port* p) {
 388                 AudioEngine::instance()->add_pending_port_deletion (p);
 389         }
 390 };
 391
 392 boost::shared_ptr<Port>
 393 PortManager::register_port (DataType dtype, const string& portname, bool input, bool async, PortFlags flags)
 394 {
 395         boost::shared_ptr<Port> newport;
 396
 397         /* limit the possible flags that can be set */
 398
 399         flags = PortFlags (flags & (Hidden|Shadow|IsTerminal|TransportMasterPort));
 400
 401         try {
 402                 if (dtype == DataType::AUDIO) {
 403                         DEBUG_TRACE (DEBUG::Ports, string_compose ("registering AUDIO port %1, input %2\n",
 404                                                                    portname, input));
 405                         newport.reset (new AudioPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags)),
 406                                        PortDeleter());
 407                 } else if (dtype == DataType::MIDI) {
 408                         if (async) {
 409                                 DEBUG_TRACE (DEBUG::Ports, string_compose ("registering ASYNC MIDI port %1, input %2\n",
 410                                                                            portname, input));
 411                                 newport.reset (new AsyncMIDIPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags)),
 412                                                PortDeleter());
 413                         } else {
 414                                 DEBUG_TRACE (DEBUG::Ports, string_compose ("registering MIDI port %1, input %2\n",
 415                                                                            portname, input));
 416                                 newport.reset (new MidiPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags)),
 417                                                PortDeleter());
 418                         }
 419                 } else {
 420                         throw PortRegistrationFailure (string_compose ("unable to create port '%1': %2", portname, _("(unknown type)")));
 421                 }
 422
 423                 newport->set_buffer_size (AudioEngine::instance()->samples_per_cycle());
 424
 425                 RCUWriter<Ports> writer (ports);
 426                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 427                 ps->insert (make_pair (make_port_name_relative (portname), newport));
 428
 429                 /* writer goes out of scope, forces update */
 430         }
 431
 432         catch (PortRegistrationFailure& err) {
 433                 throw err;
 434         } catch (std::exception& e) {
 435                 throw PortRegistrationFailure (string_compose ("unable to create port '%1': %2", portname, e.what()).c_str());
 436         } catch (...) {
 437                 throw PortRegistrationFailure (string_compose ("unable to create port '%1': %2", portname, _("(unknown error)")));
 438         }
 439
 440         DEBUG_TRACE (DEBUG::Ports, string_compose ("\t%2 port registration success, ports now = %1\n", ports.reader()->size(), this));
 441         return newport;
 442 }
 443
 444 boost::shared_ptr<Port>
 445 PortManager::register_input_port (DataType type, const string& portname, bool async, PortFlags extra_flags)
 446 {
 447         return register_port (type, portname, true, async, extra_flags);
 448 }
 449
 450 boost::shared_ptr<Port>
 451 PortManager::register_output_port (DataType type, const string& portname, bool async, PortFlags extra_flags)
 452 {
 453         return register_port (type, portname, false, async, extra_flags);
 454 }
 455
 456 int
 457 PortManager::unregister_port (boost::shared_ptr<Port> port)
 458 {
 459         /* This is a little subtle. We do not call the backend's port
 460          * unregistration code from here. That is left for the Port
 461          * destructor. We are trying to drop references to the Port object
 462          * here, so that its destructor will run and it will unregister itself.
 463          */
 464
 465         /* caller must hold process lock */
 466
 467         {
 468                 RCUWriter<Ports> writer (ports);
 469                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 470                 Ports::iterator x = ps->find (make_port_name_relative (port->name()));
 471
 472                 if (x != ps->end()) {
 473                         DEBUG_TRACE (DEBUG::Ports, string_compose ("removing %1 from port map (uc=%2)\n", port->name(), port.use_count()));
 474                         ps->erase (x);
 475                 }
 476
 477                 /* writer goes out of scope, forces update */
 478         }
 479
 480         ports.flush ();
 481
 482         return 0;
 483 }
 484
 485 bool
 486 PortManager::connected (const string& port_name)
 487 {
 488         if (!_backend) {
 489                 return false;
 490         }
 491
 492         PortEngine::PortHandle handle = _backend->get_port_by_name (port_name);
 493
 494         if (!handle) {
 495                 return false;
 496         }
 497
 498         return _backend->connected (handle);
 499 }
 500
 501 bool
 502 PortManager::physically_connected (const string& port_name)
 503 {
 504         if (!_backend) {
 505                 return false;
 506         }
 507
 508         PortEngine::PortHandle handle = _backend->get_port_by_name (port_name);
 509
 510         if (!handle) {
 511                 return false;
 512         }
 513
 514         return _backend->physically_connected (handle);
 515 }
 516
 517 int
 518 PortManager::get_connections (const string& port_name, std::vector<std::string>& s)
 519 {
 520         if (!_backend) {
 521                 s.clear ();
 522                 return 0;
 523         }
 524
 525         PortEngine::PortHandle handle = _backend->get_port_by_name (port_name);
 526
 527         if (!handle) {
 528                 s.clear ();
 529                 return 0;
 530         }
 531
 532         return _backend->get_connections (handle, s);
 533 }
 534
 535 int
 536 PortManager::connect (const string& source, const string& destination)
 537 {
 538         int ret;
 539
 540         string s = make_port_name_non_relative (source);
 541         string d = make_port_name_non_relative (destination);
 542
 543         boost::shared_ptr<Port> src = get_port_by_name (s);
 544         boost::shared_ptr<Port> dst = get_port_by_name (d);
 545
 546         if (src) {
 547                 ret = src->connect (d);
 548         } else if (dst) {
 549                 ret = dst->connect (s);
 550         } else {
 551                 /* neither port is known to us ...hand-off to the PortEngine
 552                  */
 553                 if (_backend) {
 554                         ret = _backend->connect (s, d);
 555                 } else {
 556                         ret = -1;
 557                 }
 558         }
 559
 560         if (ret > 0) {
 561                 /* already exists - no error, no warning */
 562         } else if (ret < 0) {
 563                 error << string_compose(_("AudioEngine: cannot connect %1 (%2) to %3 (%4)"),
 564                                         source, s, destination, d)
 565                       << endmsg;
 566         }
 567
 568         return ret;
 569 }
 570
 571 int
 572 PortManager::disconnect (const string& source, const string& destination)
 573 {
 574         int ret;
 575
 576         string s = make_port_name_non_relative (source);
 577         string d = make_port_name_non_relative (destination);
 578
 579         boost::shared_ptr<Port> src = get_port_by_name (s);
 580         boost::shared_ptr<Port> dst = get_port_by_name (d);
 581
 582         if (src) {
 583                 ret = src->disconnect (d);
 584         } else if (dst) {
 585                 ret = dst->disconnect (s);
 586         } else {
 587                 /* neither port is known to us ...hand-off to the PortEngine
 588                  */
 589                 if (_backend) {
 590                         ret = _backend->disconnect (s, d);
 591                 } else {
 592                         ret = -1;
 593                 }
 594         }
 595         return ret;
 596 }
 597
 598 int
 599 PortManager::disconnect (boost::shared_ptr<Port> port)
 600 {
 601         return port->disconnect_all ();
 602 }
 603
 604 int
 605 PortManager::disconnect (std::string const & name)
 606 {
 607         PortEngine::PortHandle ph = _backend->get_port_by_name (name);
 608         if (ph) {
 609                 return _backend->disconnect_all (ph);
 610         }
 611         return -2;
 612 }
 613
 614 int
 615 PortManager::reestablish_ports ()
 616 {
 617         Ports::iterator i;
 618
 619         boost::shared_ptr<Ports> p = ports.reader ();
 620
 621         DEBUG_TRACE (DEBUG::Ports, string_compose ("reestablish %1 ports\n", p->size()));
 622
 623         for (i = p->begin(); i != p->end(); ++i) {
 624                 if (i->second->reestablish ()) {
 625                         error << string_compose (_("Re-establising port %1 failed"), i->second->name()) << endmsg;
 626                         std::cerr << string_compose (_("Re-establising port %1 failed"), i->second->name()) << std::endl;
 627                         break;
 628                 }
 629         }
 630
 631         if (i != p->end()) {
 632                 /* failed */
 633                 remove_all_ports ();
 634                 return -1;
 635         }
 636
 637         return 0;
 638 }
 639
 640 int
 641 PortManager::reconnect_ports ()
 642 {
 643         boost::shared_ptr<Ports> p = ports.reader ();
 644
 645         /* re-establish connections */
 646
 647         DEBUG_TRACE (DEBUG::Ports, string_compose ("reconnect %1 ports\n", p->size()));
 648
 649         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 650                 i->second->reconnect ();
 651         }
 652
 653         return 0;
 654 }
 655
 656 void
 657 PortManager::connect_callback (const string& a, const string& b, bool conn)
 658 {
 659         DEBUG_TRACE (DEBUG::BackendCallbacks, string_compose (X_("connect callback %1 + %2 connected ? %3\n"), a, b, conn));
 660
 661         boost::shared_ptr<Port> port_a;
 662         boost::shared_ptr<Port> port_b;
 663         Ports::iterator x;
 664         boost::shared_ptr<Ports> pr = ports.reader ();
 665
 666         x = pr->find (make_port_name_relative (a));
 667         if (x != pr->end()) {
 668                 port_a = x->second;
 669         }
 670
 671         x = pr->find (make_port_name_relative (b));
 672         if (x != pr->end()) {
 673                 port_b = x->second;
 674         }
 675
 676         if (conn) {
 677                 if (port_a && !port_b) {
 678                         port_a->increment_external_connections ();
 679                 } else if (port_b && !port_a) {
 680                         port_b->increment_external_connections ();
 681                 }
 682         } else {
 683                 if (port_a && !port_b) {
 684                         port_a->decrement_external_connections ();
 685                 } else if (port_b && !port_a) {
 686                         port_b->decrement_external_connections ();
 687                 }
 688         }
 689
 690         PortConnectedOrDisconnected (
 691                 port_a, a,
 692                 port_b, b,
 693                 conn
 694                 ); /* EMIT SIGNAL */
 695 }
 696
 697 void
 698 PortManager::registration_callback ()
 699 {
 700         DEBUG_TRACE (DEBUG::BackendCallbacks, "port registration callback\n");
 701
 702         if (!_port_remove_in_progress) {
 703
 704                 {
 705                         Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
 706                         midi_info_dirty = true;
 707                 }
 708
 709                 PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
 710         }
 711 }
 712
 713 bool
 714 PortManager::can_request_input_monitoring () const
 715 {
 716         if (!_backend) {
 717                 return false;
 718         }
 719
 720         return _backend->can_monitor_input ();
 721 }
 722
 723 void
 724 PortManager::request_input_monitoring (const string& name, bool yn) const
 725 {
 726         if (!_backend) {
 727                 return;
 728         }
 729
 730         PortEngine::PortHandle ph = _backend->get_port_by_name (name);
 731
 732         if (ph) {
 733                 _backend->request_input_monitoring (ph, yn);
 734         }
 735 }
 736
 737 void
 738 PortManager::ensure_input_monitoring (const string& name, bool yn) const
 739 {
 740         if (!_backend) {
 741                 return;
 742         }
 743
 744         PortEngine::PortHandle ph = _backend->get_port_by_name (name);
 745
 746         if (ph) {
 747                 _backend->ensure_input_monitoring (ph, yn);
 748         }
 749 }
 750
 751 uint32_t
 752 PortManager::port_name_size() const
 753 {
 754         if (!_backend) {
 755                 return 0;
 756         }
 757
 758         return _backend->port_name_size ();
 759 }
 760
 761 string
 762 PortManager::my_name() const
 763 {
 764         if (!_backend) {
 765                 return string();
 766         }
 767
 768         return _backend->my_name();
 769 }
 770
 771 int
 772 PortManager::graph_order_callback ()
 773 {
 774         DEBUG_TRACE (DEBUG::BackendCallbacks, "graph order callback\n");
 775
 776         if (!_port_remove_in_progress) {
 777                 GraphReordered(); /* EMIT SIGNAL */
 778         }
 779
 780         return 0;
 781 }
 782
 783 void
 784 PortManager::cycle_start (pframes_t nframes, Session* s)
 785 {
 786         Port::set_global_port_buffer_offset (0);
 787         Port::set_cycle_samplecnt (nframes);
 788
 789         _cycle_ports = ports.reader ();
 790
 791         /* TODO optimize
 792          *  - when speed == 1.0, the resampler copies data without processing
 793          *   it may (or may not) be more efficient to just run all in sequence.
 794          *
 795          *  - single sequential task for 'lightweight' tasks would make sense
 796          *    (run it in parallel with 'heavy' resampling.
 797          *    * output ports (sends_output()) only set a flag
 798          *    * midi-ports only scale event timestamps
 799          *
 800          *  - a threshold parallel vs searial processing may be appropriate.
 801          *    amount of work (how many connected ports are there, how
 802          *    many resamplers need to run) vs. available CPU cores and semaphore
 803          *    synchronization overhead.
 804          *
 805          *  - input ports: it would make sense to resample each input only once
 806          *    (rather than resample into each ardour-owned input port).
 807          *    A single external source-port may be connected to many ardour
 808          *    input-ports. Currently re-sampling is per input.
 809          */
 810         if (s && s->rt_tasklist () && fabs (Port::speed_ratio ()) != 1.0) {
 811                 RTTaskList::TaskList tl;
 812                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 813                         if (!(p->second->flags() & TransportMasterPort)) {
 814                                 tl.push_back (boost::bind (&Port::cycle_start, p->second, nframes));
 815                         }
 816                 }
 817                 s->rt_tasklist()->process (tl);
 818         } else {
 819                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 820                         if (!(p->second->flags() & TransportMasterPort)) {
 821                                 p->second->cycle_start (nframes);
 822                         }
 823                 }
 824         }
 825 }
 826
 827 void
 828 PortManager::cycle_end (pframes_t nframes, Session* s)
 829 {
 830         // see optimzation note in ::cycle_start()
 831         if (0 && s && s->rt_tasklist () && fabs (Port::speed_ratio ()) != 1.0) {
 832                 RTTaskList::TaskList tl;
 833                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 834                         if (!(p->second->flags() & TransportMasterPort)) {
 835                                 tl.push_back (boost::bind (&Port::cycle_end, p->second, nframes));
 836                         }
 837                 }
 838                 s->rt_tasklist()->process (tl);
 839         } else {
 840                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 841                         if (!(p->second->flags() & TransportMasterPort)) {
 842                                 p->second->cycle_end (nframes);
 843                         }
 844                 }
 845         }
 846
 847         for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 848                 p->second->flush_buffers (nframes);
 849         }
 850
 851         _cycle_ports.reset ();
 852
 853         /* we are done */
 854 }
 855
 856 void
 857 PortManager::silence (pframes_t nframes, Session *s)
 858 {
 859         for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) {
 860                 if (s && i->second == s->mtc_output_port ()) {
 861                         continue;
 862                 }
 863                 if (s && i->second == s->midi_clock_output_port ()) {
 864                         continue;
 865                 }
 866                 if (s && i->second == s->ltc_output_port ()) {
 867                         continue;
 868                 }
 869                 if (boost::dynamic_pointer_cast<AsyncMIDIPort>(i->second)) {
 870                         continue;
 871                 }
 872                 if (i->second->sends_output()) {
 873                         i->second->get_buffer(nframes).silence(nframes);
 874                 }
 875         }
 876 }
 877
 878 void
 879 PortManager::silence_outputs (pframes_t nframes)
 880 {
 881         std::vector<std::string> port_names;
 882         if (get_ports("", DataType::AUDIO, IsOutput, port_names)) {
 883                 for (std::vector<std::string>::iterator p = port_names.begin(); p != port_names.end(); ++p) {
 884                         if (!port_is_mine(*p)) {
 885                                 continue;
 886                         }
 887                         PortEngine::PortHandle ph = _backend->get_port_by_name (*p);
 888                         if (!ph) {
 889                                 continue;
 890                         }
 891                         void *buf = _backend->get_buffer(ph, nframes);
 892                         if (!buf) {
 893                                 continue;
 894                         }
 895                         memset (buf, 0, sizeof(float) * nframes);
 896                 }
 897         }
 898
 899         if (get_ports("", DataType::MIDI, IsOutput, port_names)) {
 900                 for (std::vector<std::string>::iterator p = port_names.begin(); p != port_names.end(); ++p) {
 901                         if (!port_is_mine(*p)) {
 902                                 continue;
 903                         }
 904                         PortEngine::PortHandle ph = _backend->get_port_by_name (*p);
 905                         if (!ph) {
 906                                 continue;
 907                         }
 908                         void *buf = _backend->get_buffer(ph, nframes);
 909                         if (!buf) {
 910                                 continue;
 911                         }
 912                         _backend->midi_clear (buf);
 913                 }
 914         }
 915 }
 916
 917 void
 918 PortManager::check_monitoring ()
 919 {
 920         for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) {
 921
 922                 bool x;
 923
 924                 if (i->second->last_monitor() != (x = i->second->monitoring_input ())) {
 925                         i->second->set_last_monitor (x);
 926                         /* XXX I think this is dangerous, due to
 927                            a likely mutex in the signal handlers ...
 928                         */
 929                         i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
 930                 }
 931         }
 932 }
 933
 934 void
 935 PortManager::cycle_end_fade_out (gain_t base_gain, gain_t gain_step, pframes_t nframes, Session* s)
 936 {
 937         // see optimzation note in ::cycle_start()
 938         if (0 && s && s->rt_tasklist () && fabs (Port::speed_ratio ()) != 1.0) {
 939                 RTTaskList::TaskList tl;
 940                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 941                         if (!(p->second->flags() & TransportMasterPort)) {
 942                                 tl.push_back (boost::bind (&Port::cycle_end, p->second, nframes));
 943                         }
 944                 }
 945                 s->rt_tasklist()->process (tl);
 946         } else {
 947                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 948                         if (!(p->second->flags() & TransportMasterPort)) {
 949                                 p->second->cycle_end (nframes);
 950                         }
 951                 }
 952         }
 953
 954         for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 955                 p->second->flush_buffers (nframes);
 956
 957                 if (p->second->sends_output()) {
 958
 959                         boost::shared_ptr<AudioPort> ap = boost::dynamic_pointer_cast<AudioPort> (p->second);
 960                         if (ap) {
 961                                 Sample* s = ap->engine_get_whole_audio_buffer ();
 962                                 gain_t g = base_gain;
 963
 964                                 for (pframes_t n = 0; n < nframes; ++n) {
 965                                         *s++ *= g;
 966                                         g -= gain_step;
 967                                 }
 968                         }
 969                 }
 970         }
 971         _cycle_ports.reset ();
 972         /* we are done */
 973 }
 974
 975 PortEngine&
 976 PortManager::port_engine()
 977 {
 978         assert (_backend);
 979         return *_backend;
 980 }
 981
 982 bool
 983 PortManager::port_is_control_only (std::string const& name)
 984 {
 985         static regex_t compiled_pattern;
 986         static string pattern;
 987
 988         if (pattern.empty()) {
 989
 990                 /* This is a list of regular expressions that match ports
 991                  * related to physical MIDI devices that we do not want to
 992                  * expose as normal physical ports.
 993                  */
 994
 995                 const char * const control_only_ports[] = {
 996                         X_(".*Ableton Push.*"),
 997                         X_(".*FaderPort .*"),
 998                         X_(".*FaderPort8 .*"),
 999                         X_(".*FaderPort16 .*"),
1000                         X_(".*FaderPort2 .*"),
1001                         X_(".*US-2400 .*"),
1002                         X_(".*Mackie .*"),
1003                 };
1004
1005                 pattern = "(";
1006                 for (size_t n = 0; n < sizeof (control_only_ports)/sizeof (control_only_ports[0]); ++n) {
1007                         if (n > 0) {
1008                                 pattern += '|';
1009                         }
1010                         pattern += control_only_ports[n];
1011                 }
1012                 pattern += ')';
1013
1014                 regcomp (&compiled_pattern, pattern.c_str(), REG_EXTENDED|REG_NOSUB);
1015         }
1016
1017         return regexec (&compiled_pattern, name.c_str(), 0, 0, 0) == 0;
1018 }
1019
1020 PortManager::MidiPortInformation
1021 PortManager::midi_port_information (std::string const & name)
1022 {
1023         Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1024
1025         fill_midi_port_info_locked ();
1026
1027         MidiPortInfo::iterator x = midi_port_info.find (name);
1028
1029         if (x != midi_port_info.end()) {
1030                 return x->second;
1031         }
1032
1033         return MidiPortInformation ();
1034 }
1035
1036 void
1037 PortManager::get_known_midi_ports (vector<string>& copy)
1038 {
1039         Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1040
1041         fill_midi_port_info_locked ();
1042
1043         for (MidiPortInfo::const_iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
1044                 copy.push_back (x->first);
1045         }
1046 }
1047
1048 void
1049 PortManager::get_midi_selection_ports (vector<string>& copy)
1050 {
1051         Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1052
1053         fill_midi_port_info_locked ();
1054
1055         for (MidiPortInfo::const_iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
1056                 if (x->second.properties & MidiPortSelection) {
1057                         copy.push_back (x->first);
1058                 }
1059         }
1060 }
1061
1062 void
1063 PortManager::set_port_pretty_name (string const & port, string const & pretty)
1064 {
1065         {
1066                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1067
1068                 fill_midi_port_info_locked ();
1069
1070                 MidiPortInfo::iterator x = midi_port_info.find (port);
1071                 if (x == midi_port_info.end()) {
1072                         return;
1073                 }
1074                 x->second.pretty_name = pretty;
1075         }
1076
1077         /* push into back end */
1078
1079         PortEngine::PortHandle ph = _backend->get_port_by_name (port);
1080
1081         if (ph) {
1082                 _backend->set_port_property (ph, "http://jackaudio.org/metadata/pretty-name", pretty, string());
1083         }
1084
1085         save_midi_port_info ();
1086         MidiPortInfoChanged (); /* EMIT SIGNAL*/
1087 }
1088
1089 void
1090 PortManager::add_midi_port_flags (string const & port, MidiPortFlags flags)
1091 {
1092         bool emit = false;
1093
1094         {
1095                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1096
1097                 fill_midi_port_info_locked ();
1098
1099                 MidiPortInfo::iterator x = midi_port_info.find (port);
1100
1101                 if (x != midi_port_info.end()) {
1102                         if ((x->second.properties & flags) != flags) { // at least one missing
1103                                 x->second.properties = MidiPortFlags (x->second.properties | flags);
1104                                 emit = true;
1105                         }
1106                 }
1107         }
1108
1109         if (emit) {
1110                 if (flags & MidiPortSelection) {
1111                         MidiSelectionPortsChanged (); /* EMIT SIGNAL */
1112                 }
1113
1114                 if (flags != MidiPortSelection) {
1115                         MidiPortInfoChanged (); /* EMIT SIGNAL */
1116                 }
1117
1118                 save_midi_port_info ();
1119         }
1120 }
1121
1122 void
1123 PortManager::remove_midi_port_flags (string const & port, MidiPortFlags flags)
1124 {
1125         bool emit = false;
1126
1127         {
1128                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1129
1130                 fill_midi_port_info_locked ();
1131
1132                 MidiPortInfo::iterator x = midi_port_info.find (port);
1133
1134                 if (x != midi_port_info.end()) {
1135                         if (x->second.properties & flags) { // at least one is set
1136                                 x->second.properties = MidiPortFlags (x->second.properties & ~flags);
1137                                 emit = true;
1138                         }
1139                 }
1140         }
1141
1142         if (emit) {
1143                 if (flags & MidiPortSelection) {
1144                         MidiSelectionPortsChanged (); /* EMIT SIGNAL */
1145                 }
1146
1147                 if (flags != MidiPortSelection) {
1148                         MidiPortInfoChanged (); /* EMIT SIGNAL */
1149                 }
1150
1151                 save_midi_port_info ();
1152         }
1153 }
1154
1155 string
1156 PortManager::midi_port_info_file ()
1157 {
1158         return Glib::build_filename (user_config_directory(), X_("midi_port_info"));
1159 }
1160
1161 void
1162 PortManager::save_midi_port_info ()
1163 {
1164         string path = midi_port_info_file ();
1165
1166         XMLNode* root = new XMLNode (X_("MidiPortInfo"));
1167
1168         {
1169                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1170
1171                 if (midi_port_info.empty()) {
1172                         delete root;
1173                         return;
1174                 }
1175
1176                 for (MidiPortInfo::iterator i = midi_port_info.begin(); i != midi_port_info.end(); ++i) {
1177                         XMLNode* node = new XMLNode (X_("port"));
1178                         node->set_property (X_("name"), i->first);
1179                         node->set_property (X_("backend"), i->second.backend);
1180                         node->set_property (X_("pretty-name"), i->second.pretty_name);
1181                         node->set_property (X_("input"), i->second.input);
1182                         node->set_property (X_("properties"), i->second.properties);
1183                         root->add_child_nocopy (*node);
1184                 }
1185         }
1186
1187         XMLTree tree;
1188
1189         tree.set_root (root);
1190
1191         if (!tree.write (path)) {
1192                 error << string_compose (_("Could not save MIDI port info to %1"), path) << endmsg;
1193         }
1194 }
1195
1196 void
1197 PortManager::load_midi_port_info ()
1198 {
1199         string path = midi_port_info_file ();
1200         XMLTree tree;
1201
1202         if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
1203                 return;
1204         }
1205
1206         if (!tree.read (path)) {
1207                 error << string_compose (_("Cannot load MIDI port info from %1"), path) << endmsg;
1208                 return;
1209         }
1210
1211         midi_port_info.clear ();
1212
1213         for (XMLNodeConstIterator i = tree.root()->children().begin(); i != tree.root()->children().end(); ++i) {
1214                 string name;
1215                 string backend;
1216                 string pretty;
1217                 bool  input;
1218                 MidiPortFlags properties;
1219
1220
1221                 if (!(*i)->get_property (X_("name"), name) ||
1222                     !(*i)->get_property (X_("backend"), backend) ||
1223                     !(*i)->get_property (X_("pretty-name"), pretty) ||
1224                     !(*i)->get_property (X_("input"), input) ||
1225                     !(*i)->get_property (X_("properties"), properties)) {
1226                         /* should only affect version changes */
1227                         error << string_compose (_("MIDI port info file %1 contains invalid information - please remove it."), path) << endmsg;
1228                         continue;
1229                 }
1230
1231                 MidiPortInformation mpi (backend, pretty, input, properties, false);
1232
1233                 midi_port_info.insert (make_pair (name, mpi));
1234         }
1235 }
1236
1237 void
1238 PortManager::fill_midi_port_info ()
1239 {
1240         {
1241                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1242                 fill_midi_port_info_locked ();
1243         }
1244 }
1245
1246 string
1247 PortManager::short_port_name_from_port_name (std::string const & full_name) const
1248 {
1249         string::size_type colon = full_name.find_first_of (':');
1250         if (colon == string::npos || colon == full_name.length()) {
1251                 return full_name;
1252         }
1253         return full_name.substr (colon+1);
1254 }
1255
1256 void
1257 PortManager::fill_midi_port_info_locked ()
1258 {
1259         /* MIDI info mutex MUST be held */
1260
1261         if (!midi_info_dirty || !_backend) {
1262                 return;
1263         }
1264
1265         std::vector<string> ports;
1266
1267         AudioEngine::instance()->get_ports (string(), DataType::MIDI, IsOutput, ports);
1268
1269         for (vector<string>::iterator p = ports.begin(); p != ports.end(); ++p) {
1270
1271                 /* ugly hack, ideally we'd use a port-flag, or at vkbd_output_port()->name() */
1272                 if (port_is_mine (*p) && *p != _backend->my_name() + ":" + _("Virtual Keyboard")) {
1273                         continue;
1274                 }
1275
1276                 if (midi_port_info.find (*p) == midi_port_info.end()) {
1277
1278                         MidiPortFlags flags (MidiPortFlags (0));
1279
1280                         if (port_is_control_only (*p)) {
1281                                 flags = MidiPortControl;
1282                         }
1283
1284                         MidiPortInformation mpi (_backend->name(), *p, true, flags, true);
1285
1286 #ifdef LINUX
1287                         if ((*p.find (X_("Midi Through")) != string::npos || (*p).find (X_("Midi-Through")) != string::npos)) {
1288                                 mpi.properties = MidiPortFlags (mpi.properties | MidiPortVirtual);
1289                         }
1290 #endif
1291                         midi_port_info.insert (make_pair (*p, mpi));
1292                 }
1293         }
1294
1295         AudioEngine::instance()->get_ports (string(), DataType::MIDI, IsInput, ports);
1296
1297         for (vector<string>::iterator p = ports.begin(); p != ports.end(); ++p) {
1298
1299                 if (port_is_mine (*p)) {
1300                         continue;
1301                 }
1302
1303                 if (midi_port_info.find (*p) == midi_port_info.end()) {
1304
1305                         MidiPortFlags flags (MidiPortFlags (0));
1306
1307                         if (port_is_control_only (*p)) {
1308                                 flags = MidiPortControl;
1309                         }
1310
1311                         MidiPortInformation mpi (_backend->name(), *p, false, flags, true);
1312
1313 #ifdef LINUX
1314                         if ((*p.find (X_("Midi Through")) != string::npos || (*p).find (X_("Midi-Through")) != string::npos)) {
1315                                 mpi.properties = MidiPortFlags (mpi.properties | MidiPortVirtual);
1316                         }
1317 #endif
1318                         midi_port_info.insert (make_pair (*p, mpi));
1319                 }
1320         }
1321
1322         /* now check with backend about which ports are present and pull
1323          * pretty-name if it exists
1324          */
1325
1326         for (MidiPortInfo::iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
1327
1328                 if (x->second.backend != _backend->name()) {
1329                         /* this port (info) comes from a different
1330                          * backend. While there's a reasonable chance that it
1331                          * refers to the same physical (or virtual) endpoint, we
1332                          * don't allow its use with this backend.
1333                         */
1334                         x->second.exists = false;
1335                         continue;
1336                 }
1337
1338                 PortEngine::PortHandle ph = _backend->get_port_by_name (x->first);
1339
1340                 if (!ph) {
1341                         /* port info saved from some condition where this port
1342                          * existed, but no longer does (i.e. device unplugged
1343                          * at present). We don't remove it from midi_port_info.
1344                          */
1345                         x->second.exists = false;
1346
1347                 } else {
1348                         x->second.exists = true;
1349
1350                         /* check with backend for pre-existing pretty name */
1351
1352                         string value = AudioEngine::instance()->get_pretty_name_by_name (x->first);
1353
1354                         if (!value.empty()) {
1355                                 x->second.pretty_name = value;
1356                         }
1357                 }
1358         }
1359
1360         midi_info_dirty = false;
1361 }
1362
1363 void
1364 PortManager::set_port_buffer_sizes (pframes_t n)
1365 {
1366
1367         boost::shared_ptr<Ports> all = ports.reader();
1368
1369         for (Ports::iterator p = all->begin(); p != all->end(); ++p) {
1370                 p->second->set_buffer_size (n);
1371         }
1372 }