libs/ardour/io.cc

   1 /*
   2     Copyright (C) 2000-2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <fstream>
  20 #include <algorithm>
  21 #include <unistd.h>
  22 #include <locale.h>
  23 #include <errno.h>
  24
  25
  26 #include <glibmm.h>
  27 #include <glibmm/thread.h>
  28
  29 #include "pbd/xml++.h"
  30 #include "pbd/replace_all.h"
  31 #include "pbd/unknown_type.h"
  32 #include "pbd/enumwriter.h"
  33
  34 #include "ardour/audioengine.h"
  35 #include "ardour/buffer.h"
  36 #include "ardour/io.h"
  37 #include "ardour/route.h"
  38 #include "ardour/port.h"
  39 #include "ardour/audio_port.h"
  40 #include "ardour/midi_port.h"
  41 #include "ardour/session.h"
  42 #include "ardour/cycle_timer.h"
  43 #include "ardour/buffer_set.h"
  44 #include "ardour/meter.h"
  45 #include "ardour/amp.h"
  46 #include "ardour/user_bundle.h"
  47
  48 #include "i18n.h"
  49
  50 #include <cmath>
  51
  52 /*
  53   A bug in OS X's cmath that causes isnan() and isinf() to be
  54   "undeclared". the following works around that
  55 */
  56
  57 #if defined(__APPLE__) && defined(__MACH__)
  58 extern "C" int isnan (double);
  59 extern "C" int isinf (double);
  60 #endif
  61
  62 #define BLOCK_PROCESS_CALLBACK() Glib::Mutex::Lock em (_session.engine().process_lock())
  63
  64 using namespace std;
  65 using namespace ARDOUR;
  66 using namespace PBD;
  67
  68 const string                 IO::state_node_name = "IO";
  69 bool                         IO::connecting_legal = false;
  70 PBD::Signal0<int>            IO::ConnectingLegal;
  71 PBD::Signal1<void,ChanCount> IO::PortCountChanged;
  72
  73 /** @param default_type The type of port that will be created by ensure_io
  74  * and friends if no type is explicitly requested (to avoid breakage).
  75  */
  76 IO::IO (Session& s, const string& name, Direction dir, DataType default_type)
  77         : SessionObject (s, name)
  78         , _direction (dir)
  79         , _default_type (default_type)
  80 {
  81         _active = true;
  82         pending_state_node = 0;
  83         setup_bundle ();
  84 }
  85
  86 IO::IO (Session& s, const XMLNode& node, DataType dt)
  87         : SessionObject(s, "unnamed io")
  88         , _direction (Input)
  89         , _default_type (dt)
  90 {
  91         _active = true;
  92         pending_state_node = 0;
  93
  94         set_state (node, Stateful::loading_state_version);
  95         setup_bundle ();
  96 }
  97
  98 IO::~IO ()
  99 {
 100         Glib::Mutex::Lock lm (io_lock);
 101
 102         BLOCK_PROCESS_CALLBACK ();
 103
 104         for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
 105                 _session.engine().unregister_port (*i);
 106         }
 107 }
 108
 109 void
 110 IO::silence (nframes_t nframes)
 111 {
 112         /* io_lock, not taken: function must be called from Session::process() calltree */
 113
 114         for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
 115                 i->get_buffer(nframes).silence (nframes);
 116         }
 117 }
 118
 119 void
 120 IO::check_bundles_connected ()
 121 {
 122         check_bundles (_bundles_connected, ports());
 123 }
 124
 125 void
 126 IO::check_bundles (std::vector<UserBundleInfo*>& list, const PortSet& ports)
 127 {
 128         std::vector<UserBundleInfo*> new_list;
 129
 130         for (std::vector<UserBundleInfo*>::iterator i = list.begin(); i != list.end(); ++i) {
 131
 132                 uint32_t const N = (*i)->bundle->nchannels ();
 133
 134                 if (_ports.num_ports (default_type()) < N) {
 135                         continue;
 136                 }
 137
 138                 bool ok = true;
 139
 140                 for (uint32_t j = 0; j < N; ++j) {
 141                         /* Every port on bundle channel j must be connected to our input j */
 142                         Bundle::PortList const pl = (*i)->bundle->channel_ports (j);
 143                         for (uint32_t k = 0; k < pl.size(); ++k) {
 144                                 if (ports.port(j)->connected_to (pl[k]) == false) {
 145                                         ok = false;
 146                                         break;
 147                                 }
 148                         }
 149
 150                         if (ok == false) {
 151                                 break;
 152                         }
 153                 }
 154
 155                 if (ok) {
 156                         new_list.push_back (*i);
 157                 } else {
 158                         delete *i;
 159                 }
 160         }
 161
 162         list = new_list;
 163 }
 164
 165
 166 int
 167 IO::disconnect (Port* our_port, string other_port, void* src)
 168 {
 169         if (other_port.length() == 0 || our_port == 0) {
 170                 return 0;
 171         }
 172
 173         {
 174                 BLOCK_PROCESS_CALLBACK ();
 175
 176                 {
 177                         Glib::Mutex::Lock lm (io_lock);
 178
 179                         /* check that our_port is really one of ours */
 180
 181                         if ( ! _ports.contains(our_port)) {
 182                                 return -1;
 183                         }
 184
 185                         /* disconnect it from the source */
 186
 187                         if (our_port->disconnect (other_port)) {
 188                                 error << string_compose(_("IO: cannot disconnect port %1 from %2"), our_port->name(), other_port) << endmsg;
 189                                 return -1;
 190                         }
 191
 192                         check_bundles_connected ();
 193                 }
 194         }
 195
 196         changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 197         _session.set_dirty ();
 198
 199         return 0;
 200 }
 201
 202 int
 203 IO::connect (Port* our_port, string other_port, void* src)
 204 {
 205         if (other_port.length() == 0 || our_port == 0) {
 206                 return 0;
 207         }
 208
 209         {
 210                 BLOCK_PROCESS_CALLBACK ();
 211
 212                 {
 213                         Glib::Mutex::Lock lm (io_lock);
 214
 215                         /* check that our_port is really one of ours */
 216
 217                         if ( ! _ports.contains(our_port) ) {
 218                                 return -1;
 219                         }
 220
 221                         /* connect it to the source */
 222
 223                         if (our_port->connect (other_port)) {
 224                                 return -1;
 225                         }
 226                 }
 227         }
 228
 229         changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 230         _session.set_dirty ();
 231         return 0;
 232 }
 233
 234 int
 235 IO::remove_port (Port* port, void* src)
 236 {
 237         IOChange change (NoChange);
 238
 239         {
 240                 BLOCK_PROCESS_CALLBACK ();
 241
 242
 243                 {
 244                         Glib::Mutex::Lock lm (io_lock);
 245
 246                         if (_ports.remove(port)) {
 247                                 change = IOChange (change|ConfigurationChanged);
 248
 249                                 if (port->connected()) {
 250                                         change = IOChange (change|ConnectionsChanged);
 251                                 }
 252
 253                                 _session.engine().unregister_port (*port);
 254                                 check_bundles_connected ();
 255                         }
 256                 }
 257
 258                 PortCountChanged (n_ports()); /* EMIT SIGNAL */
 259         }
 260
 261         if (change & ConfigurationChanged) {
 262                 setup_bundle ();
 263         }
 264
 265         if (change != NoChange) {
 266                 changed (change, src);
 267                 _session.set_dirty ();
 268                 return 0;
 269         }
 270
 271         return -1;
 272 }
 273
 274 /** Add an output port.
 275  *
 276  * @param destination Name of input port to connect new port to.
 277  * @param src Source for emitted ConfigurationChanged signal.
 278  * @param type Data type of port.  Default value (NIL) will use this IO's default type.
 279  */
 280 int
 281 IO::add_port (string destination, void* src, DataType type)
 282 {
 283         Port* our_port;
 284
 285         if (type == DataType::NIL) {
 286                 type = _default_type;
 287         }
 288
 289         {
 290                 BLOCK_PROCESS_CALLBACK ();
 291
 292
 293                 {
 294                         Glib::Mutex::Lock lm (io_lock);
 295
 296                         /* Create a new output port */
 297
 298                         string portname = build_legal_port_name (type);
 299
 300                         if (_direction == Input) {
 301                                 if ((our_port = _session.engine().register_input_port (type, portname)) == 0) {
 302                                         error << string_compose(_("IO: cannot register input port %1"), portname) << endmsg;
 303                                         return -1;
 304                                 }
 305                         } else {
 306                                 if ((our_port = _session.engine().register_output_port (type, portname)) == 0) {
 307                                         error << string_compose(_("IO: cannot register output port %1"), portname) << endmsg;
 308                                         return -1;
 309                                 }
 310                         }
 311
 312                         _ports.add (our_port);
 313                 }
 314
 315                 PortCountChanged (n_ports()); /* EMIT SIGNAL */
 316         }
 317
 318         if (destination.length()) {
 319                 if (our_port->connect (destination)) {
 320                         return -1;
 321                 }
 322         }
 323
 324         // pan_changed (src); /* EMIT SIGNAL */
 325         changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 326         setup_bundle ();
 327         _session.set_dirty ();
 328
 329         return 0;
 330 }
 331
 332 int
 333 IO::disconnect (void* src)
 334 {
 335         {
 336                 BLOCK_PROCESS_CALLBACK ();
 337
 338                 {
 339                         Glib::Mutex::Lock lm (io_lock);
 340
 341                         for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
 342                                 i->disconnect_all ();
 343                         }
 344
 345                         check_bundles_connected ();
 346                 }
 347         }
 348
 349         changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 350
 351         return 0;
 352 }
 353
 354 bool
 355 IO::ensure_ports_locked (ChanCount count, bool clear, void* /*src*/)
 356 {
 357         Port* port = 0;
 358         bool  changed    = false;
 359
 360         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 361
 362                 const size_t n = count.get(*t);
 363
 364                 /* remove unused ports */
 365                 for (size_t i = n_ports().get(*t); i > n; --i) {
 366                         port = _ports.port(*t, i-1);
 367
 368                         assert(port);
 369                         _ports.remove(port);
 370                         _session.engine().unregister_port (*port);
 371
 372                         changed = true;
 373                 }
 374
 375                 /* create any necessary new ports */
 376                 while (n_ports().get(*t) < n) {
 377
 378                         string portname = build_legal_port_name (*t);
 379
 380                         try {
 381
 382                                 if (_direction == Input) {
 383                                         if ((port = _session.engine().register_input_port (*t, portname)) == 0) {
 384                                                 error << string_compose(_("IO: cannot register input port %1"), portname) << endmsg;
 385                                                 return -1;
 386                                         }
 387                                 } else {
 388                                         if ((port = _session.engine().register_output_port (*t, portname)) == 0) {
 389                                                 error << string_compose(_("IO: cannot register output port %1"), portname) << endmsg;
 390                                                 return -1;
 391                                         }
 392                                 }
 393                         }
 394
 395                         catch (AudioEngine::PortRegistrationFailure& err) {
 396                                 /* pass it on */
 397                                 throw AudioEngine::PortRegistrationFailure();
 398                         }
 399
 400                         _ports.add (port);
 401                         changed = true;
 402                 }
 403         }
 404
 405         if (changed) {
 406                 check_bundles_connected ();
 407                 PortCountChanged (n_ports()); /* EMIT SIGNAL */
 408                 _session.set_dirty ();
 409         }
 410
 411         if (clear) {
 412                 /* disconnect all existing ports so that we get a fresh start */
 413                 for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
 414                         i->disconnect_all ();
 415                 }
 416         }
 417
 418         return changed;
 419 }
 420
 421
 422 int
 423 IO::ensure_ports (ChanCount count, bool clear, bool lockit, void* src)
 424 {
 425         bool changed = false;
 426
 427         if (count == n_ports() && !clear) {
 428                 return 0;
 429         }
 430
 431         if (lockit) {
 432                 BLOCK_PROCESS_CALLBACK ();
 433                 Glib::Mutex::Lock im (io_lock);
 434                 changed = ensure_ports_locked (count, clear, src);
 435         } else {
 436                 changed = ensure_ports_locked (count, clear, src);
 437         }
 438
 439         if (changed) {
 440                 this->changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 441                 setup_bundle ();
 442                 _session.set_dirty ();
 443         }
 444
 445         return 0;
 446 }
 447
 448 int
 449 IO::ensure_io (ChanCount count, bool clear, void* src)
 450 {
 451         return ensure_ports (count, clear, true, src);
 452 }
 453
 454 XMLNode&
 455 IO::get_state (void)
 456 {
 457         return state (true);
 458 }
 459
 460 XMLNode&
 461 IO::state (bool /*full_state*/)
 462 {
 463         XMLNode* node = new XMLNode (state_node_name);
 464         char buf[64];
 465         string str;
 466         vector<string>::iterator ci;
 467         int n;
 468         LocaleGuard lg (X_("POSIX"));
 469         Glib::Mutex::Lock lm (io_lock);
 470
 471         node->add_property("name", _name);
 472         id().print (buf, sizeof (buf));
 473         node->add_property("id", buf);
 474         node->add_property ("direction", enum_2_string (_direction));
 475         node->add_property ("default-type", _default_type.to_string());
 476
 477         for (std::vector<UserBundleInfo*>::iterator i = _bundles_connected.begin(); i != _bundles_connected.end(); ++i) {
 478                 XMLNode* n = new XMLNode ("Bundle");
 479                 n->add_property ("name", (*i)->bundle->name ());
 480                 node->add_child_nocopy (*n);
 481         }
 482
 483         for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
 484
 485                 vector<string> connections;
 486
 487                 XMLNode* pnode = new XMLNode (X_("Port"));
 488                 pnode->add_property (X_("type"), i->type().to_string());
 489                 pnode->add_property (X_("name"), i->name());
 490
 491                 if (i->get_connections (connections)) {
 492
 493                         for (n = 0, ci = connections.begin(); ci != connections.end(); ++ci, ++n) {
 494
 495                                 /* if its a connection to our own port,
 496                                    return only the port name, not the
 497                                    whole thing. this allows connections
 498                                    to be re-established even when our
 499                                    client name is different.
 500                                 */
 501
 502                                 XMLNode* cnode = new XMLNode (X_("Connection"));
 503
 504                                 cnode->add_property (X_("other"), _session.engine().make_port_name_relative (*ci));
 505                                 pnode->add_child_nocopy (*cnode);
 506                         }
 507                 }
 508
 509                 node->add_child_nocopy (*pnode);
 510         }
 511
 512         return *node;
 513 }
 514
 515 int
 516 IO::set_state (const XMLNode& node, int version)
 517 {
 518         /* callers for version < 3000 need to call set_state_2X directly, as A3 IOs
 519          * are input OR output, not both, so the direction needs to be specified
 520          * by the caller.
 521          */
 522         assert (version >= 3000);
 523
 524         const XMLProperty* prop;
 525         XMLNodeConstIterator iter;
 526         LocaleGuard lg (X_("POSIX"));
 527
 528         /* force use of non-localized representation of decimal point,
 529            since we use it a lot in XML files and so forth.
 530         */
 531
 532         if (node.name() != state_node_name) {
 533                 error << string_compose(_("incorrect XML node \"%1\" passed to IO object"), node.name()) << endmsg;
 534                 return -1;
 535         }
 536
 537         if ((prop = node.property ("name")) != 0) {
 538                 set_name (prop->value());
 539         }
 540
 541         if ((prop = node.property (X_("default-type"))) != 0) {
 542                 _default_type = DataType(prop->value());
 543                 assert(_default_type != DataType::NIL);
 544         }
 545
 546         if ((prop = node.property ("id")) != 0) {
 547                 _id = prop->value ();
 548         }
 549
 550         if ((prop = node.property ("direction")) != 0) {
 551                 _direction = (Direction) string_2_enum (prop->value(), _direction);
 552         }
 553
 554         if (create_ports (node, version)) {
 555                 return -1;
 556         }
 557
 558         if (connecting_legal) {
 559
 560                 if (make_connections (node, version, false)) {
 561                         return -1;
 562                 }
 563
 564         } else {
 565
 566                 pending_state_node = new XMLNode (node);
 567                 pending_state_node_version = version;
 568                 pending_state_node_in = false;
 569                 ConnectingLegal.connect_same_thread (connection_legal_c, boost::bind (&IO::connecting_became_legal, this));
 570         }
 571
 572
 573         return 0;
 574 }
 575
 576 int
 577 IO::set_state_2X (const XMLNode& node, int version, bool in)
 578 {
 579         const XMLProperty* prop;
 580         XMLNodeConstIterator iter;
 581         LocaleGuard lg (X_("POSIX"));
 582
 583         /* force use of non-localized representation of decimal point,
 584            since we use it a lot in XML files and so forth.
 585         */
 586
 587         if (node.name() != state_node_name) {
 588                 error << string_compose(_("incorrect XML node \"%1\" passed to IO object"), node.name()) << endmsg;
 589                 return -1;
 590         }
 591
 592         if ((prop = node.property ("name")) != 0) {
 593                 set_name (prop->value());
 594         }
 595
 596         if ((prop = node.property (X_("default-type"))) != 0) {
 597                 _default_type = DataType(prop->value());
 598                 assert(_default_type != DataType::NIL);
 599         }
 600
 601         if ((prop = node.property ("id")) != 0) {
 602                 _id = prop->value ();
 603         }
 604
 605         _direction = in ? Input : Output;
 606
 607         if (create_ports (node, version)) {
 608                 return -1;
 609         }
 610
 611         if (connecting_legal) {
 612
 613                 if (make_connections_2X (node, version, in)) {
 614                         return -1;
 615                 }
 616
 617         } else {
 618
 619                 pending_state_node = new XMLNode (node);
 620                 pending_state_node_version = version;
 621                 pending_state_node_in = in;
 622                 ConnectingLegal.connect_same_thread (connection_legal_c, boost::bind (&IO::connecting_became_legal, this));
 623         }
 624
 625         return 0;
 626 }
 627
 628 int
 629 IO::connecting_became_legal ()
 630 {
 631         int ret;
 632
 633         assert (pending_state_node);
 634
 635         connection_legal_c.disconnect ();
 636
 637         ret = make_connections (*pending_state_node, pending_state_node_version, pending_state_node_in);
 638
 639         delete pending_state_node;
 640         pending_state_node = 0;
 641
 642         return ret;
 643 }
 644
 645 boost::shared_ptr<Bundle>
 646 IO::find_possible_bundle (const string &desired_name)
 647 {
 648         static const string digits = "0123456789";
 649         const string &default_name = (_direction == Input ? _("in") : _("out"));
 650         const string &bundle_type_name = (_direction == Input ? _("input") : _("output"));
 651
 652         boost::shared_ptr<Bundle> c = _session.bundle_by_name (desired_name);
 653
 654         if (!c) {
 655                 int bundle_number, mask;
 656                 string possible_name;
 657                 bool stereo = false;
 658                 string::size_type last_non_digit_pos;
 659
 660                 error << string_compose(_("Unknown bundle \"%1\" listed for %2 of %3"), desired_name, bundle_type_name, _name)
 661                       << endmsg;
 662
 663                 // find numeric suffix of desired name
 664                 bundle_number = 0;
 665
 666                 last_non_digit_pos = desired_name.find_last_not_of(digits);
 667
 668                 if (last_non_digit_pos != string::npos) {
 669                         stringstream s;
 670                         s << desired_name.substr(last_non_digit_pos);
 671                         s >> bundle_number;
 672                 }
 673
 674                 // see if it's a stereo connection e.g. "in 3+4"
 675
 676                 if (last_non_digit_pos > 1 && desired_name[last_non_digit_pos] == '+') {
 677                         int left_bundle_number = 0;
 678                         string::size_type left_last_non_digit_pos;
 679
 680                         left_last_non_digit_pos = desired_name.find_last_not_of(digits, last_non_digit_pos-1);
 681
 682                         if (left_last_non_digit_pos != string::npos) {
 683                                 stringstream s;
 684                                 s << desired_name.substr(left_last_non_digit_pos, last_non_digit_pos-1);
 685                                 s >> left_bundle_number;
 686
 687                                 if (left_bundle_number > 0 && left_bundle_number + 1 == bundle_number) {
 688                                         bundle_number--;
 689                                         stereo = true;
 690                                 }
 691                         }
 692                 }
 693
 694                 // make 0-based
 695                 if (bundle_number)
 696                         bundle_number--;
 697
 698                 // find highest set bit
 699                 mask = 1;
 700                 while ((mask <= bundle_number) && (mask <<= 1)) {}
 701
 702                 // "wrap" bundle number into largest possible power of 2
 703                 // that works...
 704
 705                 while (mask) {
 706
 707                         if (bundle_number & mask) {
 708                                 bundle_number &= ~mask;
 709
 710                                 stringstream s;
 711                                 s << default_name << " " << bundle_number + 1;
 712
 713                                 if (stereo) {
 714                                         s << "+" << bundle_number + 2;
 715                                 }
 716
 717                                 possible_name = s.str();
 718
 719                                 if ((c = _session.bundle_by_name (possible_name)) != 0) {
 720                                         break;
 721                                 }
 722                         }
 723                         mask >>= 1;
 724                 }
 725                 if (c) {
 726                         info << string_compose (_("Bundle %1 was not available - \"%2\" used instead"), desired_name, possible_name)
 727                              << endmsg;
 728                 } else {
 729                         error << string_compose(_("No %1 bundles available as a replacement"), bundle_type_name)
 730                               << endmsg;
 731                 }
 732
 733         }
 734
 735         return c;
 736
 737 }
 738
 739 int
 740 IO::get_port_counts_2X (XMLNode const & node, int /*version*/, ChanCount& n, boost::shared_ptr<Bundle>& /*c*/)
 741 {
 742         XMLProperty const * prop;
 743         XMLNodeList children = node.children ();
 744
 745         uint32_t n_audio = 0;
 746
 747         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
 748
 749                 if ((prop = node.property ("inputs")) != 0 && _direction == Input) {
 750                         n_audio = count (prop->value().begin(), prop->value().end(), '{');
 751                 } else if ((prop = node.property ("outputs")) != 0 && _direction == Output) {
 752                         n_audio = count (prop->value().begin(), prop->value().end(), '{');
 753                 }
 754         }
 755
 756         ChanCount cnt;
 757         cnt.set_audio (n_audio);
 758         n = ChanCount::max (n, cnt);
 759
 760         return 0;
 761 }
 762
 763 int
 764 IO::get_port_counts (const XMLNode& node, int version, ChanCount& n, boost::shared_ptr<Bundle>& c)
 765 {
 766         if (version < 3000) {
 767                 return get_port_counts_2X (node, version, n, c);
 768         }
 769
 770         XMLProperty const * prop;
 771         XMLNodeConstIterator iter;
 772         uint32_t n_audio = 0;
 773         uint32_t n_midi = 0;
 774         ChanCount cnt;
 775
 776         n = n_ports();
 777
 778         if ((prop = node.property ("connection")) != 0) {
 779
 780                 if ((c = find_possible_bundle (prop->value())) != 0) {
 781                         n = ChanCount::max (n, ChanCount(c->type(), c->nchannels()));
 782                 }
 783                 return 0;
 784         }
 785
 786         for (iter = node.children().begin(); iter != node.children().end(); ++iter) {
 787
 788                 if ((*iter)->name() == X_("Bundle")) {
 789                         if ((c = find_possible_bundle (prop->value())) != 0) {
 790                                 n = ChanCount::max (n, ChanCount(c->type(), c->nchannels()));
 791                                 return 0;
 792                         } else {
 793                                 return -1;
 794                         }
 795                 }
 796
 797                 if ((*iter)->name() == X_("Port")) {
 798                         prop = (*iter)->property (X_("type"));
 799
 800                         if (!prop) {
 801                                 continue;
 802                         }
 803
 804                         if (prop->value() == X_("audio")) {
 805                                 cnt.set_audio (++n_audio);
 806                         } else if (prop->value() == X_("midi")) {
 807                                 cnt.set_midi (++n_midi);
 808                         }
 809                 }
 810         }
 811
 812         n = ChanCount::max (n, cnt);
 813         return 0;
 814 }
 815
 816 int
 817 IO::create_ports (const XMLNode& node, int version)
 818 {
 819         ChanCount n;
 820         boost::shared_ptr<Bundle> c;
 821
 822         get_port_counts (node, version, n, c);
 823
 824         if (ensure_ports (n, true, true, this)) {
 825                 error << string_compose(_("%1: cannot create I/O ports"), _name) << endmsg;
 826                 return -1;
 827         }
 828
 829         /* XXX use c */
 830
 831         return 0;
 832 }
 833
 834 int
 835 IO::make_connections (const XMLNode& node, int version, bool in)
 836 {
 837         if (version < 3000) {
 838                 return make_connections_2X (node, version, in);
 839         }
 840
 841         const XMLProperty* prop;
 842
 843         for (XMLNodeConstIterator i = node.children().begin(); i != node.children().end(); ++i) {
 844
 845                 if ((*i)->name() == "Bundle") {
 846                         XMLProperty const * prop = (*i)->property ("name");
 847                         if (prop) {
 848                                 boost::shared_ptr<Bundle> b = find_possible_bundle (prop->value());
 849                                 if (b) {
 850                                         connect_ports_to_bundle (b, this);
 851                                 }
 852                         }
 853
 854                         return 0;
 855                 }
 856
 857                 if ((*i)->name() == "Port") {
 858
 859                         prop = (*i)->property (X_("name"));
 860
 861                         if (!prop) {
 862                                 continue;
 863                         }
 864
 865                         Port* p = port_by_name (prop->value());
 866
 867                         if (p) {
 868                                 for (XMLNodeConstIterator c = (*i)->children().begin(); c != (*i)->children().end(); ++c) {
 869
 870                                         XMLNode* cnode = (*c);
 871
 872                                         if (cnode->name() != X_("Connection")) {
 873                                                 continue;
 874                                         }
 875
 876                                         if ((prop = cnode->property (X_("other"))) == 0) {
 877                                                 continue;
 878                                         }
 879
 880                                         if (prop) {
 881                                                 p->connect (prop->value());
 882                                         }
 883                                 }
 884                         }
 885                 }
 886         }
 887
 888         return 0;
 889 }
 890
 891
 892 int
 893 IO::make_connections_2X (const XMLNode& node, int /*version*/, bool in)
 894 {
 895         const XMLProperty* prop;
 896
 897         /* XXX: bundles ("connections" as was) */
 898
 899         if ((prop = node.property ("inputs")) != 0 && in) {
 900
 901                 string::size_type ostart = 0;
 902                 string::size_type start = 0;
 903                 string::size_type end = 0;
 904                 int i = 0;
 905                 int n;
 906                 vector<string> ports;
 907
 908                 string const str = prop->value ();
 909
 910                 while ((start = str.find_first_of ('{', ostart)) != string::npos) {
 911                         start += 1;
 912
 913                         if ((end = str.find_first_of ('}', start)) == string::npos) {
 914                                 error << string_compose(_("IO: badly formed string in XML node for inputs \"%1\""), str) << endmsg;
 915                                 return -1;
 916                         }
 917
 918                         if ((n = parse_io_string (str.substr (start, end - start), ports)) < 0) {
 919                                 error << string_compose(_("bad input string in XML node \"%1\""), str) << endmsg;
 920
 921                                 return -1;
 922
 923                         } else if (n > 0) {
 924
 925
 926                                 for (int x = 0; x < n; ++x) {
 927                                         /* XXX: this is a bit of a hack; need to check if it's always valid */
 928                                         string::size_type const p = ports[x].find ("/out");
 929                                         if (p != string::npos) {
 930                                                 ports[x].replace (p, 4, "/audio_out");
 931                                         }
 932                                         nth(i)->connect (ports[x]);
 933                                 }
 934                         }
 935
 936                         ostart = end+1;
 937                         i++;
 938                 }
 939
 940         }
 941
 942         if ((prop = node.property ("outputs")) != 0 && !in) {
 943
 944                 string::size_type ostart = 0;
 945                 string::size_type start = 0;
 946                 string::size_type end = 0;
 947                 int i = 0;
 948                 int n;
 949                 vector<string> ports;
 950
 951                 string const str = prop->value ();
 952
 953                 while ((start = str.find_first_of ('{', ostart)) != string::npos) {
 954                         start += 1;
 955
 956                         if ((end = str.find_first_of ('}', start)) == string::npos) {
 957                                 error << string_compose(_("IO: badly formed string in XML node for outputs \"%1\""), str) << endmsg;
 958                                 return -1;
 959                         }
 960
 961                         if ((n = parse_io_string (str.substr (start, end - start), ports)) < 0) {
 962                                 error << string_compose(_("IO: bad output string in XML node \"%1\""), str) << endmsg;
 963
 964                                 return -1;
 965
 966                         } else if (n > 0) {
 967
 968                                 for (int x = 0; x < n; ++x) {
 969                                         /* XXX: this is a bit of a hack; need to check if it's always valid */
 970                                         string::size_type const p = ports[x].find ("/in");
 971                                         if (p != string::npos) {
 972                                                 ports[x].replace (p, 3, "/audio_in");
 973                                         }
 974                                         nth(i)->connect (ports[x]);
 975                                 }
 976                         }
 977
 978                         ostart = end+1;
 979                         i++;
 980                 }
 981         }
 982
 983         return 0;
 984 }
 985
 986 int
 987 IO::set_ports (const string& str)
 988 {
 989         vector<string> ports;
 990         int i;
 991         int n;
 992         uint32_t nports;
 993
 994         if ((nports = count (str.begin(), str.end(), '{')) == 0) {
 995                 return 0;
 996         }
 997
 998         // FIXME: audio-only
 999         if (ensure_ports (ChanCount(DataType::AUDIO, nports), true, true, this)) {
1000                 return -1;
1001         }
1002
1003         string::size_type start, end, ostart;
1004
1005         ostart = 0;
1006         start = 0;
1007         end = 0;
1008         i = 0;
1009
1010         while ((start = str.find_first_of ('{', ostart)) != string::npos) {
1011                 start += 1;
1012
1013                 if ((end = str.find_first_of ('}', start)) == string::npos) {
1014                         error << string_compose(_("IO: badly formed string in XML node for inputs \"%1\""), str) << endmsg;
1015                         return -1;
1016                 }
1017
1018                 if ((n = parse_io_string (str.substr (start, end - start), ports)) < 0) {
1019                         error << string_compose(_("bad input string in XML node \"%1\""), str) << endmsg;
1020
1021                         return -1;
1022
1023                 } else if (n > 0) {
1024
1025                         for (int x = 0; x < n; ++x) {
1026                                 connect (nth (i), ports[x], this);
1027                         }
1028                 }
1029
1030                 ostart = end+1;
1031                 i++;
1032         }
1033
1034         return 0;
1035 }
1036
1037 int
1038 IO::parse_io_string (const string& str, vector<string>& ports)
1039 {
1040         string::size_type pos, opos;
1041
1042         if (str.length() == 0) {
1043                 return 0;
1044         }
1045
1046         pos = 0;
1047         opos = 0;
1048
1049         ports.clear ();
1050
1051         while ((pos = str.find_first_of (',', opos)) != string::npos) {
1052                 ports.push_back (str.substr (opos, pos - opos));
1053                 opos = pos + 1;
1054         }
1055
1056         if (opos < str.length()) {
1057                 ports.push_back (str.substr(opos));
1058         }
1059
1060         return ports.size();
1061 }
1062
1063 int
1064 IO::parse_gain_string (const string& str, vector<string>& ports)
1065 {
1066         string::size_type pos, opos;
1067
1068         pos = 0;
1069         opos = 0;
1070         ports.clear ();
1071
1072         while ((pos = str.find_first_of (',', opos)) != string::npos) {
1073                 ports.push_back (str.substr (opos, pos - opos));
1074                 opos = pos + 1;
1075         }
1076
1077         if (opos < str.length()) {
1078                 ports.push_back (str.substr(opos));
1079         }
1080
1081         return ports.size();
1082 }
1083
1084 bool
1085 IO::set_name (const string& requested_name)
1086 {
1087         string name = requested_name;
1088
1089         if (_name == name) {
1090                 return true;
1091         }
1092
1093         /* replace all colons in the name. i wish we didn't have to do this */
1094
1095         if (replace_all (name, ":", "-")) {
1096                 warning << _("you cannot use colons to name objects with I/O connections") << endmsg;
1097         }
1098
1099         for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
1100                 string current_name = i->name();
1101                 current_name.replace (current_name.find (_name), _name.val().length(), name);
1102                 i->set_name (current_name);
1103         }
1104
1105         bool const r = SessionObject::set_name (name);
1106
1107         setup_bundle ();
1108
1109         return r;
1110 }
1111
1112 void
1113 IO::set_port_latency (nframes_t nframes)
1114 {
1115         Glib::Mutex::Lock lm (io_lock);
1116
1117         for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
1118                 i->set_latency (nframes);
1119         }
1120 }
1121
1122 nframes_t
1123 IO::latency () const
1124 {
1125         nframes_t max_latency;
1126         nframes_t latency;
1127
1128         max_latency = 0;
1129
1130         /* io lock not taken - must be protected by other means */
1131
1132         for (PortSet::const_iterator i = _ports.begin(); i != _ports.end(); ++i) {
1133                 if ((latency = i->total_latency ()) > max_latency) {
1134                         max_latency = latency;
1135                 }
1136         }
1137
1138         return max_latency;
1139 }
1140
1141 void
1142 IO::update_port_total_latencies ()
1143 {
1144         /* io_lock, not taken: function must be called from Session::process() calltree */
1145
1146         for (PortSet::iterator i = _ports.begin(); i != _ports.end(); ++i) {
1147                 _session.engine().update_total_latency (*i);
1148         }
1149 }
1150
1151 int
1152 IO::connect_ports_to_bundle (boost::shared_ptr<Bundle> c, void* src)
1153 {
1154         {
1155                 BLOCK_PROCESS_CALLBACK ();
1156                 Glib::Mutex::Lock lm2 (io_lock);
1157
1158                 c->connect (_bundle, _session.engine());
1159
1160                 /* If this is a UserBundle, make a note of what we've done */
1161
1162                 boost::shared_ptr<UserBundle> ub = boost::dynamic_pointer_cast<UserBundle> (c);
1163                 if (ub) {
1164
1165                         /* See if we already know about this one */
1166                         std::vector<UserBundleInfo*>::iterator i = _bundles_connected.begin();
1167                         while (i != _bundles_connected.end() && (*i)->bundle != ub) {
1168                                 ++i;
1169                         }
1170
1171                         if (i == _bundles_connected.end()) {
1172                                 /* We don't, so make a note */
1173                                 _bundles_connected.push_back (new UserBundleInfo (this, ub));
1174                         }
1175                 }
1176         }
1177
1178         changed (IOChange (ConfigurationChanged|ConnectionsChanged), src); /* EMIT SIGNAL */
1179         return 0;
1180 }
1181
1182 int
1183 IO::disconnect_ports_from_bundle (boost::shared_ptr<Bundle> c, void* src)
1184 {
1185         {
1186                 BLOCK_PROCESS_CALLBACK ();
1187                 Glib::Mutex::Lock lm2 (io_lock);
1188
1189                 c->disconnect (_bundle, _session.engine());
1190
1191                 /* If this is a UserBundle, make a note of what we've done */
1192
1193                 boost::shared_ptr<UserBundle> ub = boost::dynamic_pointer_cast<UserBundle> (c);
1194                 if (ub) {
1195
1196                         std::vector<UserBundleInfo*>::iterator i = _bundles_connected.begin();
1197                         while (i != _bundles_connected.end() && (*i)->bundle != ub) {
1198                                 ++i;
1199                         }
1200
1201                         if (i != _bundles_connected.end()) {
1202                                 delete *i;
1203                                 _bundles_connected.erase (i);
1204                         }
1205                 }
1206         }
1207
1208         changed (IOChange (ConfigurationChanged|ConnectionsChanged), src); /* EMIT SIGNAL */
1209         return 0;
1210 }
1211
1212
1213 int
1214 IO::disable_connecting ()
1215 {
1216         connecting_legal = false;
1217         return 0;
1218 }
1219
1220 int
1221 IO::enable_connecting ()
1222 {
1223         connecting_legal = true;
1224         boost::optional<int> r = ConnectingLegal ();
1225         return r.get_value_or (0);
1226 }
1227
1228 void
1229 IO::bundle_changed (Bundle::Change /*c*/)
1230 {
1231         //XXX
1232 //      connect_input_ports_to_bundle (_input_bundle, this);
1233 }
1234
1235
1236 string
1237 IO::build_legal_port_name (DataType type)
1238 {
1239         const int name_size = jack_port_name_size();
1240         int limit;
1241         string suffix;
1242
1243         if (type == DataType::AUDIO) {
1244                 suffix = _("audio");
1245         } else if (type == DataType::MIDI) {
1246                 suffix = _("midi");
1247         } else {
1248                 throw unknown_type();
1249         }
1250
1251         /* note that if "in" or "out" are translated it will break a session
1252            across locale switches because a port's connection list will
1253            show (old) translated names, but the current port name will
1254            use the (new) translated name.
1255         */
1256
1257         if (_direction == Input) {
1258                 suffix += X_("_in");
1259         } else {
1260                 suffix += X_("_out");
1261         }
1262
1263         // allow up to 4 digits for the output port number, plus the slash, suffix and extra space
1264
1265         limit = name_size - _session.engine().client_name().length() - (suffix.length() + 5);
1266
1267         char buf1[name_size+1];
1268         char buf2[name_size+1];
1269
1270         snprintf (buf1, name_size+1, ("%.*s/%s"), limit, _name.val().c_str(), suffix.c_str());
1271
1272         int port_number = find_port_hole (buf1);
1273         snprintf (buf2, name_size+1, "%s %d", buf1, port_number);
1274
1275         return string (buf2);
1276 }
1277
1278 int32_t
1279 IO::find_port_hole (const char* base)
1280 {
1281         /* CALLER MUST HOLD IO LOCK */
1282
1283         uint32_t n;
1284
1285         if (_ports.empty()) {
1286                 return 1;
1287         }
1288
1289         /* we only allow up to 4 characters for the port number
1290          */
1291
1292         for (n = 1; n < 9999; ++n) {
1293                 char buf[jack_port_name_size()];
1294                 PortSet::iterator i = _ports.begin();
1295
1296                 snprintf (buf, jack_port_name_size(), _("%s %u"), base, n);
1297
1298                 for ( ; i != _ports.end(); ++i) {
1299                         if (i->name() == buf) {
1300                                 break;
1301                         }
1302                 }
1303
1304                 if (i == _ports.end()) {
1305                         break;
1306                 }
1307         }
1308         return n;
1309 }
1310
1311
1312 AudioPort*
1313 IO::audio(uint32_t n) const
1314 {
1315         return _ports.nth_audio_port (n);
1316
1317 }
1318
1319 MidiPort*
1320 IO::midi(uint32_t n) const
1321 {
1322         return _ports.nth_midi_port (n);
1323 }
1324
1325 /**
1326  *  Setup a bundle that describe our inputs or outputs. Also creates the bundle if necessary.
1327  */
1328
1329 void
1330 IO::setup_bundle ()
1331 {
1332         char buf[32];
1333
1334         if (!_bundle) {
1335                 _bundle.reset (new Bundle (_direction == Input));
1336         }
1337
1338         _bundle->suspend_signals ();
1339
1340         _bundle->set_type (default_type ());
1341
1342         _bundle->remove_channels ();
1343
1344         if (_direction == Input) {
1345                 snprintf(buf, sizeof (buf), _("%s in"), _name.val().c_str());
1346         } else {
1347                 snprintf(buf, sizeof (buf), _("%s out"), _name.val().c_str());
1348         }
1349         _bundle->set_name (buf);
1350         uint32_t const ni = _ports.num_ports();
1351         for (uint32_t i = 0; i < ni; ++i) {
1352                 _bundle->add_channel (bundle_channel_name (i, ni));
1353                 _bundle->set_port (i, _session.engine().make_port_name_non_relative (_ports.port(i)->name()));
1354         }
1355
1356         _bundle->resume_signals ();
1357 }
1358
1359 /** @return Bundles connected to our ports */
1360 BundleList
1361 IO::bundles_connected ()
1362 {
1363         BundleList bundles;
1364
1365         /* User bundles */
1366         for (std::vector<UserBundleInfo*>::iterator i = _bundles_connected.begin(); i != _bundles_connected.end(); ++i) {
1367                 bundles.push_back ((*i)->bundle);
1368         }
1369
1370         /* Session bundles */
1371         boost::shared_ptr<ARDOUR::BundleList> b = _session.bundles ();
1372         for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
1373                 if ((*i)->connected_to (_bundle, _session.engine())) {
1374                         bundles.push_back (*i);
1375                 }
1376         }
1377
1378         /* Route bundles */
1379
1380         boost::shared_ptr<ARDOUR::RouteList> r = _session.get_routes ();
1381
1382         if (_direction == Input) {
1383                 for (ARDOUR::RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1384                         if ((*i)->output()->bundle()->connected_to (_bundle, _session.engine())) {
1385                                 bundles.push_back ((*i)->output()->bundle());
1386                         }
1387                 }
1388         } else {
1389                 for (ARDOUR::RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1390                         if ((*i)->input()->bundle()->connected_to (_bundle, _session.engine())) {
1391                                 bundles.push_back ((*i)->input()->bundle());
1392                         }
1393                 }
1394         }
1395
1396         return bundles;
1397 }
1398
1399
1400 IO::UserBundleInfo::UserBundleInfo (IO* io, boost::shared_ptr<UserBundle> b)
1401 {
1402         bundle = b;
1403         b->Changed.connect_same_thread (changed, boost::bind (&IO::bundle_changed, io, _1));
1404 }
1405
1406 std::string
1407 IO::bundle_channel_name (uint32_t c, uint32_t n) const
1408 {
1409         char buf[32];
1410
1411         switch (n) {
1412         case 1:
1413                 return _("mono");
1414         case 2:
1415                 return c == 0 ? _("L") : _("R");
1416         default:
1417                 snprintf (buf, sizeof(buf), _("%d"), (c + 1));
1418                 return buf;
1419         }
1420
1421         return "";
1422 }
1423
1424 string
1425 IO::name_from_state (const XMLNode& node)
1426 {
1427         const XMLProperty* prop;
1428
1429         if ((prop = node.property ("name")) != 0) {
1430                 return prop->value();
1431         }
1432
1433         return string();
1434 }
1435
1436 void
1437 IO::set_name_in_state (XMLNode& node, const string& new_name)
1438 {
1439         const XMLProperty* prop;
1440
1441         if ((prop = node.property ("name")) != 0) {
1442                 node.add_property ("name", new_name);
1443         }
1444 }
1445
1446 bool
1447 IO::connected_to (boost::shared_ptr<const IO> other) const
1448 {
1449         if (!other) {
1450                 /* do we have any connections at all? */
1451
1452                 for (PortSet::const_iterator p = _ports.begin(); p != _ports.end(); ++p) {
1453                         if (p->connected()) {
1454                                 return true;
1455                         }
1456                 }
1457
1458                 return false;
1459         }
1460
1461         assert (_direction != other->direction());
1462
1463         uint32_t i, j;
1464         uint32_t no = n_ports().n_total();
1465         uint32_t ni = other->n_ports ().n_total();
1466
1467         for (i = 0; i < no; ++i) {
1468                 for (j = 0; j < ni; ++j) {
1469                         if (nth(i)->connected_to (other->nth(j)->name())) {
1470                                 return true;
1471                         }
1472                 }
1473         }
1474
1475         return false;
1476 }
1477
1478 void
1479 IO::process_input (boost::shared_ptr<Processor> proc, sframes_t start_frame, sframes_t end_frame, nframes_t nframes)
1480 {
1481         BufferSet bufs;
1482
1483         /* don't read the data into new buffers - just use the port buffers directly */
1484
1485         bufs.attach_buffers (_ports, nframes, 0);
1486         proc->run (bufs, start_frame, end_frame, nframes, true);
1487 }
1488
1489 void
1490 IO::collect_input (BufferSet& bufs, nframes_t nframes, ChanCount offset)
1491 {
1492         assert(bufs.available() >= _ports.count());
1493
1494         if (_ports.count() == ChanCount::ZERO) {
1495                 return;
1496         }
1497
1498         bufs.set_count (_ports.count());
1499
1500         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1501                 PortSet::iterator   i = _ports.begin(*t);
1502                 BufferSet::iterator b = bufs.begin(*t);
1503
1504                 for (uint32_t off = 0; off < offset.get(*t); ++off, ++b) {
1505                         if (b == bufs.end(*t)) {
1506                                 continue;
1507                         }
1508                 }
1509
1510                 for ( ; i != _ports.end(*t); ++i, ++b) {
1511                         Buffer& bb (i->get_buffer (nframes));
1512                         b->read_from (bb, nframes);
1513                 }
1514         }
1515 }
1516
1517 void
1518 IO::copy_to_outputs (BufferSet& bufs, DataType type, nframes_t nframes, nframes_t offset)
1519 {
1520         // Copy any buffers 1:1 to outputs
1521
1522         PortSet::iterator o = _ports.begin(type);
1523         BufferSet::iterator i = bufs.begin(type);
1524         BufferSet::iterator prev = i;
1525
1526         while (i != bufs.end(type) && o != _ports.end (type)) {
1527                 Buffer& port_buffer (o->get_buffer (nframes));
1528                 port_buffer.read_from (*i, nframes, offset);
1529                 prev = i;
1530                 ++i;
1531                 ++o;
1532         }
1533
1534         // Copy last buffer to any extra outputs
1535
1536         while (o != _ports.end(type)) {
1537                 Buffer& port_buffer (o->get_buffer (nframes));
1538                 port_buffer.read_from (*prev, nframes, offset);
1539                 ++o;
1540         }
1541 }
1542
1543 Port*
1544 IO::port_by_name (const std::string& str) const
1545 {
1546         /* to be called only from ::set_state() - no locking */
1547
1548         for (PortSet::const_iterator i = _ports.begin(); i != _ports.end(); ++i) {
1549
1550                 const Port& p(*i);
1551
1552                 if (p.name() == str) {
1553                         return const_cast<Port*>(&p);
1554                 }
1555         }
1556
1557         return 0;
1558 }