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                 /* AudioEngine::split_cycle flushes buffers until Port::port_offset.
 849                  * Now only flush remaining events (after Port::port_offset) */
 850                 p->second->flush_buffers (nframes - Port::port_offset ());
 851         }
 852
 853         _cycle_ports.reset ();
 854
 855         /* we are done */
 856 }
 857
 858 void
 859 PortManager::silence (pframes_t nframes, Session *s)
 860 {
 861         for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) {
 862                 if (s && i->second == s->mtc_output_port ()) {
 863                         continue;
 864                 }
 865                 if (s && i->second == s->midi_clock_output_port ()) {
 866                         continue;
 867                 }
 868                 if (s && i->second == s->ltc_output_port ()) {
 869                         continue;
 870                 }
 871                 if (boost::dynamic_pointer_cast<AsyncMIDIPort>(i->second)) {
 872                         continue;
 873                 }
 874                 if (i->second->sends_output()) {
 875                         i->second->get_buffer(nframes).silence(nframes);
 876                 }
 877         }
 878 }
 879
 880 void
 881 PortManager::silence_outputs (pframes_t nframes)
 882 {
 883         std::vector<std::string> port_names;
 884         if (get_ports("", DataType::AUDIO, IsOutput, port_names)) {
 885                 for (std::vector<std::string>::iterator p = port_names.begin(); p != port_names.end(); ++p) {
 886                         if (!port_is_mine(*p)) {
 887                                 continue;
 888                         }
 889                         PortEngine::PortHandle ph = _backend->get_port_by_name (*p);
 890                         if (!ph) {
 891                                 continue;
 892                         }
 893                         void *buf = _backend->get_buffer(ph, nframes);
 894                         if (!buf) {
 895                                 continue;
 896                         }
 897                         memset (buf, 0, sizeof(float) * nframes);
 898                 }
 899         }
 900
 901         if (get_ports("", DataType::MIDI, IsOutput, port_names)) {
 902                 for (std::vector<std::string>::iterator p = port_names.begin(); p != port_names.end(); ++p) {
 903                         if (!port_is_mine(*p)) {
 904                                 continue;
 905                         }
 906                         PortEngine::PortHandle ph = _backend->get_port_by_name (*p);
 907                         if (!ph) {
 908                                 continue;
 909                         }
 910                         void *buf = _backend->get_buffer(ph, nframes);
 911                         if (!buf) {
 912                                 continue;
 913                         }
 914                         _backend->midi_clear (buf);
 915                 }
 916         }
 917 }
 918
 919 void
 920 PortManager::check_monitoring ()
 921 {
 922         for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) {
 923
 924                 bool x;
 925
 926                 if (i->second->last_monitor() != (x = i->second->monitoring_input ())) {
 927                         i->second->set_last_monitor (x);
 928                         /* XXX I think this is dangerous, due to
 929                            a likely mutex in the signal handlers ...
 930                         */
 931                         i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
 932                 }
 933         }
 934 }
 935
 936 void
 937 PortManager::cycle_end_fade_out (gain_t base_gain, gain_t gain_step, pframes_t nframes, Session* s)
 938 {
 939         // see optimzation note in ::cycle_start()
 940         if (0 && s && s->rt_tasklist () && fabs (Port::speed_ratio ()) != 1.0) {
 941                 RTTaskList::TaskList tl;
 942                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 943                         if (!(p->second->flags() & TransportMasterPort)) {
 944                                 tl.push_back (boost::bind (&Port::cycle_end, p->second, nframes));
 945                         }
 946                 }
 947                 s->rt_tasklist()->process (tl);
 948         } else {
 949                 for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 950                         if (!(p->second->flags() & TransportMasterPort)) {
 951                                 p->second->cycle_end (nframes);
 952                         }
 953                 }
 954         }
 955
 956         for (Ports::iterator p = _cycle_ports->begin(); p != _cycle_ports->end(); ++p) {
 957                 p->second->flush_buffers (nframes);
 958
 959                 if (p->second->sends_output()) {
 960
 961                         boost::shared_ptr<AudioPort> ap = boost::dynamic_pointer_cast<AudioPort> (p->second);
 962                         if (ap) {
 963                                 Sample* s = ap->engine_get_whole_audio_buffer ();
 964                                 gain_t g = base_gain;
 965
 966                                 for (pframes_t n = 0; n < nframes; ++n) {
 967                                         *s++ *= g;
 968                                         g -= gain_step;
 969                                 }
 970                         }
 971                 }
 972         }
 973         _cycle_ports.reset ();
 974         /* we are done */
 975 }
 976
 977 PortEngine&
 978 PortManager::port_engine()
 979 {
 980         assert (_backend);
 981         return *_backend;
 982 }
 983
 984 bool
 985 PortManager::port_is_control_only (std::string const& name)
 986 {
 987         static regex_t compiled_pattern;
 988         static string pattern;
 989
 990         if (pattern.empty()) {
 991
 992                 /* This is a list of regular expressions that match ports
 993                  * related to physical MIDI devices that we do not want to
 994                  * expose as normal physical ports.
 995                  */
 996
 997                 const char * const control_only_ports[] = {
 998                         X_(".*Ableton Push.*"),
 999                         X_(".*FaderPort .*"),
1000                         X_(".*FaderPort8 .*"),
1001                         X_(".*FaderPort16 .*"),
1002                         X_(".*FaderPort2 .*"),
1003                         X_(".*US-2400 .*"),
1004                         X_(".*Mackie .*"),
1005                 };
1006
1007                 pattern = "(";
1008                 for (size_t n = 0; n < sizeof (control_only_ports)/sizeof (control_only_ports[0]); ++n) {
1009                         if (n > 0) {
1010                                 pattern += '|';
1011                         }
1012                         pattern += control_only_ports[n];
1013                 }
1014                 pattern += ')';
1015
1016                 regcomp (&compiled_pattern, pattern.c_str(), REG_EXTENDED|REG_NOSUB);
1017         }
1018
1019         return regexec (&compiled_pattern, name.c_str(), 0, 0, 0) == 0;
1020 }
1021
1022 PortManager::MidiPortInformation
1023 PortManager::midi_port_information (std::string const & name)
1024 {
1025         Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1026
1027         fill_midi_port_info_locked ();
1028
1029         MidiPortInfo::iterator x = midi_port_info.find (name);
1030
1031         if (x != midi_port_info.end()) {
1032                 return x->second;
1033         }
1034
1035         return MidiPortInformation ();
1036 }
1037
1038 void
1039 PortManager::get_known_midi_ports (vector<string>& copy)
1040 {
1041         Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1042
1043         fill_midi_port_info_locked ();
1044
1045         for (MidiPortInfo::const_iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
1046                 copy.push_back (x->first);
1047         }
1048 }
1049
1050 void
1051 PortManager::get_midi_selection_ports (vector<string>& copy)
1052 {
1053         Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1054
1055         fill_midi_port_info_locked ();
1056
1057         for (MidiPortInfo::const_iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
1058                 if (x->second.properties & MidiPortSelection) {
1059                         copy.push_back (x->first);
1060                 }
1061         }
1062 }
1063
1064 void
1065 PortManager::set_port_pretty_name (string const & port, string const & pretty)
1066 {
1067         {
1068                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1069
1070                 fill_midi_port_info_locked ();
1071
1072                 MidiPortInfo::iterator x = midi_port_info.find (port);
1073                 if (x == midi_port_info.end()) {
1074                         return;
1075                 }
1076                 x->second.pretty_name = pretty;
1077         }
1078
1079         /* push into back end */
1080
1081         PortEngine::PortHandle ph = _backend->get_port_by_name (port);
1082
1083         if (ph) {
1084                 _backend->set_port_property (ph, "http://jackaudio.org/metadata/pretty-name", pretty, string());
1085         }
1086
1087         save_midi_port_info ();
1088         MidiPortInfoChanged (); /* EMIT SIGNAL*/
1089 }
1090
1091 void
1092 PortManager::add_midi_port_flags (string const & port, MidiPortFlags flags)
1093 {
1094         bool emit = false;
1095
1096         {
1097                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1098
1099                 fill_midi_port_info_locked ();
1100
1101                 MidiPortInfo::iterator x = midi_port_info.find (port);
1102
1103                 if (x != midi_port_info.end()) {
1104                         if ((x->second.properties & flags) != flags) { // at least one missing
1105                                 x->second.properties = MidiPortFlags (x->second.properties | flags);
1106                                 emit = true;
1107                         }
1108                 }
1109         }
1110
1111         if (emit) {
1112                 if (flags & MidiPortSelection) {
1113                         MidiSelectionPortsChanged (); /* EMIT SIGNAL */
1114                 }
1115
1116                 if (flags != MidiPortSelection) {
1117                         MidiPortInfoChanged (); /* EMIT SIGNAL */
1118                 }
1119
1120                 save_midi_port_info ();
1121         }
1122 }
1123
1124 void
1125 PortManager::remove_midi_port_flags (string const & port, MidiPortFlags flags)
1126 {
1127         bool emit = false;
1128
1129         {
1130                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1131
1132                 fill_midi_port_info_locked ();
1133
1134                 MidiPortInfo::iterator x = midi_port_info.find (port);
1135
1136                 if (x != midi_port_info.end()) {
1137                         if (x->second.properties & flags) { // at least one is set
1138                                 x->second.properties = MidiPortFlags (x->second.properties & ~flags);
1139                                 emit = true;
1140                         }
1141                 }
1142         }
1143
1144         if (emit) {
1145                 if (flags & MidiPortSelection) {
1146                         MidiSelectionPortsChanged (); /* EMIT SIGNAL */
1147                 }
1148
1149                 if (flags != MidiPortSelection) {
1150                         MidiPortInfoChanged (); /* EMIT SIGNAL */
1151                 }
1152
1153                 save_midi_port_info ();
1154         }
1155 }
1156
1157 string
1158 PortManager::midi_port_info_file ()
1159 {
1160         return Glib::build_filename (user_config_directory(), X_("midi_port_info"));
1161 }
1162
1163 void
1164 PortManager::save_midi_port_info ()
1165 {
1166         string path = midi_port_info_file ();
1167
1168         XMLNode* root = new XMLNode (X_("MidiPortInfo"));
1169
1170         {
1171                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1172
1173                 if (midi_port_info.empty()) {
1174                         delete root;
1175                         return;
1176                 }
1177
1178                 for (MidiPortInfo::iterator i = midi_port_info.begin(); i != midi_port_info.end(); ++i) {
1179                         XMLNode* node = new XMLNode (X_("port"));
1180                         node->set_property (X_("name"), i->first);
1181                         node->set_property (X_("backend"), i->second.backend);
1182                         node->set_property (X_("pretty-name"), i->second.pretty_name);
1183                         node->set_property (X_("input"), i->second.input);
1184                         node->set_property (X_("properties"), i->second.properties);
1185                         root->add_child_nocopy (*node);
1186                 }
1187         }
1188
1189         XMLTree tree;
1190
1191         tree.set_root (root);
1192
1193         if (!tree.write (path)) {
1194                 error << string_compose (_("Could not save MIDI port info to %1"), path) << endmsg;
1195         }
1196 }
1197
1198 void
1199 PortManager::load_midi_port_info ()
1200 {
1201         string path = midi_port_info_file ();
1202         XMLTree tree;
1203
1204         if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
1205                 return;
1206         }
1207
1208         if (!tree.read (path)) {
1209                 error << string_compose (_("Cannot load MIDI port info from %1"), path) << endmsg;
1210                 return;
1211         }
1212
1213         midi_port_info.clear ();
1214
1215         for (XMLNodeConstIterator i = tree.root()->children().begin(); i != tree.root()->children().end(); ++i) {
1216                 string name;
1217                 string backend;
1218                 string pretty;
1219                 bool  input;
1220                 MidiPortFlags properties;
1221
1222
1223                 if (!(*i)->get_property (X_("name"), name) ||
1224                     !(*i)->get_property (X_("backend"), backend) ||
1225                     !(*i)->get_property (X_("pretty-name"), pretty) ||
1226                     !(*i)->get_property (X_("input"), input) ||
1227                     !(*i)->get_property (X_("properties"), properties)) {
1228                         /* should only affect version changes */
1229                         error << string_compose (_("MIDI port info file %1 contains invalid information - please remove it."), path) << endmsg;
1230                         continue;
1231                 }
1232
1233                 MidiPortInformation mpi (backend, pretty, input, properties, false);
1234
1235                 midi_port_info.insert (make_pair (name, mpi));
1236         }
1237 }
1238
1239 void
1240 PortManager::fill_midi_port_info ()
1241 {
1242         {
1243                 Glib::Threads::Mutex::Lock lm (midi_port_info_mutex);
1244                 fill_midi_port_info_locked ();
1245         }
1246 }
1247
1248 string
1249 PortManager::short_port_name_from_port_name (std::string const & full_name) const
1250 {
1251         string::size_type colon = full_name.find_first_of (':');
1252         if (colon == string::npos || colon == full_name.length()) {
1253                 return full_name;
1254         }
1255         return full_name.substr (colon+1);
1256 }
1257
1258 void
1259 PortManager::fill_midi_port_info_locked ()
1260 {
1261         /* MIDI info mutex MUST be held */
1262
1263         if (!midi_info_dirty || !_backend) {
1264                 return;
1265         }
1266
1267         std::vector<string> ports;
1268
1269         AudioEngine::instance()->get_ports (string(), DataType::MIDI, IsOutput, ports);
1270
1271         for (vector<string>::iterator p = ports.begin(); p != ports.end(); ++p) {
1272
1273                 /* ugly hack, ideally we'd use a port-flag, or at vkbd_output_port()->name() */
1274                 if (port_is_mine (*p) && *p != _backend->my_name() + ":" + _("Virtual Keyboard")) {
1275                         continue;
1276                 }
1277
1278                 if (midi_port_info.find (*p) == midi_port_info.end()) {
1279
1280                         MidiPortFlags flags (MidiPortFlags (0));
1281
1282                         if (port_is_control_only (*p)) {
1283                                 flags = MidiPortControl;
1284                         } else if (*p == _backend->my_name() + ":" + _("Virtual Keyboard")) {
1285                                 flags = MidiPortFlags(MidiPortSelection | MidiPortMusic);
1286                         }
1287
1288                         MidiPortInformation mpi (_backend->name(), *p, true, flags, true);
1289
1290 #ifdef LINUX
1291                         if ((*p.find (X_("Midi Through")) != string::npos || (*p).find (X_("Midi-Through")) != string::npos)) {
1292                                 mpi.properties = MidiPortFlags (mpi.properties | MidiPortVirtual);
1293                         }
1294 #endif
1295                         midi_port_info.insert (make_pair (*p, mpi));
1296                 }
1297         }
1298
1299         AudioEngine::instance()->get_ports (string(), DataType::MIDI, IsInput, ports);
1300
1301         for (vector<string>::iterator p = ports.begin(); p != ports.end(); ++p) {
1302
1303                 if (port_is_mine (*p)) {
1304                         continue;
1305                 }
1306
1307                 if (midi_port_info.find (*p) == midi_port_info.end()) {
1308
1309                         MidiPortFlags flags (MidiPortFlags (0));
1310
1311                         if (port_is_control_only (*p)) {
1312                                 flags = MidiPortControl;
1313                         }
1314
1315                         MidiPortInformation mpi (_backend->name(), *p, false, flags, true);
1316
1317 #ifdef LINUX
1318                         if ((*p.find (X_("Midi Through")) != string::npos || (*p).find (X_("Midi-Through")) != string::npos)) {
1319                                 mpi.properties = MidiPortFlags (mpi.properties | MidiPortVirtual);
1320                         }
1321 #endif
1322                         midi_port_info.insert (make_pair (*p, mpi));
1323                 }
1324         }
1325
1326         /* now check with backend about which ports are present and pull
1327          * pretty-name if it exists
1328          */
1329
1330         for (MidiPortInfo::iterator x = midi_port_info.begin(); x != midi_port_info.end(); ++x) {
1331
1332                 if (x->second.backend != _backend->name()) {
1333                         /* this port (info) comes from a different
1334                          * backend. While there's a reasonable chance that it
1335                          * refers to the same physical (or virtual) endpoint, we
1336                          * don't allow its use with this backend.
1337                         */
1338                         x->second.exists = false;
1339                         continue;
1340                 }
1341
1342                 PortEngine::PortHandle ph = _backend->get_port_by_name (x->first);
1343
1344                 if (!ph) {
1345                         /* port info saved from some condition where this port
1346                          * existed, but no longer does (i.e. device unplugged
1347                          * at present). We don't remove it from midi_port_info.
1348                          */
1349                         x->second.exists = false;
1350
1351                 } else {
1352                         x->second.exists = true;
1353
1354                         /* check with backend for pre-existing pretty name */
1355
1356                         string value = AudioEngine::instance()->get_pretty_name_by_name (x->first);
1357
1358                         if (!value.empty()) {
1359                                 x->second.pretty_name = value;
1360                         }
1361                 }
1362         }
1363
1364         midi_info_dirty = false;
1365 }
1366
1367 void
1368 PortManager::set_port_buffer_sizes (pframes_t n)
1369 {
1370
1371         boost::shared_ptr<Ports> all = ports.reader();
1372
1373         for (Ports::iterator p = all->begin(); p != all->end(); ++p) {
1374                 p->second->set_buffer_size (n);
1375         }
1376 }