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 #include <sigc++/bind.h>
  26
  27 #include <glibmm.h>
  28 #include <glibmm/thread.h>
  29
  30 #include <pbd/xml++.h>
  31 #include <pbd/replace_all.h>
  32 #include <pbd/unknown_type.h>
  33
  34 #include <ardour/audioengine.h>
  35 #include <ardour/io.h>
  36 #include <ardour/route.h>
  37 #include <ardour/port.h>
  38 #include <ardour/audio_port.h>
  39 #include <ardour/midi_port.h>
  40 #include <ardour/session.h>
  41 #include <ardour/cycle_timer.h>
  42 #include <ardour/panner.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 bool                         IO::ports_legal = false;
  71 bool                         IO::panners_legal = false;
  72 sigc::signal<void>           IO::Meter;
  73 sigc::signal<int>            IO::ConnectingLegal;
  74 sigc::signal<int>            IO::PortsLegal;
  75 sigc::signal<int>            IO::PannersLegal;
  76 sigc::signal<void,ChanCount> IO::PortCountChanged;
  77 sigc::signal<int>            IO::PortsCreated;
  78
  79 Glib::StaticMutex IO::m_meter_signal_lock = GLIBMM_STATIC_MUTEX_INIT;
  80
  81 /* this is a default mapper of [0 .. 1.0] control values to a gain coefficient.
  82    others can be imagined.
  83 */
  84
  85 #if 0
  86 static gain_t direct_control_to_gain (double fract) {
  87         /* XXX Marcus writes: this doesn't seem right to me. but i don't have a better answer ... */
  88         /* this maxes at +6dB */
  89         return pow (2.0,(sqrt(sqrt(sqrt(fract)))*198.0-192.0)/6.0);
  90 }
  91
  92 static double direct_gain_to_control (gain_t gain) {
  93         /* XXX Marcus writes: this doesn't seem right to me. but i don't have a better answer ... */
  94         if (gain == 0) return 0.0;
  95
  96         return pow((6.0*log(gain)/log(2.0)+192.0)/198.0, 8.0);
  97 }
  98 #endif
  99
 100 /** @param default_type The type of port that will be created by ensure_io
 101  * and friends if no type is explicitly requested (to avoid breakage).
 102  */
 103 IO::IO (Session& s, const string& name,
 104         int input_min, int input_max, int output_min, int output_max,
 105         DataType default_type, bool public_ports)
 106         : SessionObject(s, name),
 107           AutomatableControls (s),
 108           _output_buffers (new BufferSet()),
 109           _active(true),
 110           _default_type (default_type),
 111           _public_ports (public_ports),
 112           _input_minimum (ChanCount::ZERO),
 113           _input_maximum (ChanCount::INFINITE),
 114           _output_minimum (ChanCount::ZERO),
 115           _output_maximum (ChanCount::INFINITE)
 116 {
 117         _panner = new Panner (name, _session);
 118         _meter = new PeakMeter (_session);
 119
 120         if (input_min > 0) {
 121                 _input_minimum = ChanCount(_default_type, input_min);
 122         }
 123         if (input_max >= 0) {
 124                 _input_maximum = ChanCount(_default_type, input_max);
 125         }
 126         if (output_min > 0) {
 127                 _output_minimum = ChanCount(_default_type, output_min);
 128         }
 129         if (output_max >= 0) {
 130                 _output_maximum = ChanCount(_default_type, output_max);
 131         }
 132
 133         _gain = 1.0;
 134         _desired_gain = 1.0;
 135         pending_state_node = 0;
 136         no_panner_reset = false;
 137         _phase_invert = false;
 138         deferred_state = 0;
 139
 140         boost::shared_ptr<AutomationList> gl(
 141                         new AutomationList(Evoral::Parameter(GainAutomation)));
 142
 143         _gain_control = boost::shared_ptr<GainControl>( new GainControl( X_("gaincontrol"), this, Evoral::Parameter(GainAutomation), gl ));
 144
 145         add_control(_gain_control);
 146
 147         apply_gain_automation = false;
 148
 149         {
 150                 // IO::Meter is emitted from another thread so the
 151                 // Meter signal must be protected.
 152                 Glib::Mutex::Lock guard (m_meter_signal_lock);
 153                 m_meter_connection = Meter.connect (mem_fun (*this, &IO::meter));
 154         }
 155
 156         _session.add_controllable (_gain_control);
 157
 158         create_bundles_for_inputs_and_outputs ();
 159 }
 160
 161 IO::IO (Session& s, const XMLNode& node, DataType dt)
 162         : SessionObject(s, "unnamed io"),
 163           AutomatableControls (s),
 164           _output_buffers (new BufferSet()),
 165           _active(true),
 166           _default_type (dt)
 167 {
 168         _meter = new PeakMeter (_session);
 169         _public_ports = true; // XXX get this from node
 170         _panner = 0;
 171         deferred_state = 0;
 172         no_panner_reset = false;
 173         _desired_gain = 1.0;
 174         _gain = 1.0;
 175
 176         apply_gain_automation = false;
 177
 178         boost::shared_ptr<AutomationList> gl(
 179                         new AutomationList(Evoral::Parameter(GainAutomation)));
 180
 181         _gain_control = boost::shared_ptr<GainControl>(
 182                         new GainControl( X_("gaincontrol"), this, Evoral::Parameter(GainAutomation), gl));
 183
 184         add_control(_gain_control);
 185
 186         set_state (node);
 187
 188         {
 189                 // IO::Meter is emitted from another thread so the
 190                 // Meter signal must be protected.
 191                 Glib::Mutex::Lock guard (m_meter_signal_lock);
 192                 m_meter_connection = Meter.connect (mem_fun (*this, &IO::meter));
 193         }
 194
 195         _session.add_controllable (_gain_control);
 196
 197         create_bundles_for_inputs_and_outputs ();
 198 }
 199
 200 IO::~IO ()
 201 {
 202         Glib::Mutex::Lock guard (m_meter_signal_lock);
 203         Glib::Mutex::Lock lm (io_lock);
 204
 205         BLOCK_PROCESS_CALLBACK ();
 206
 207         for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 208                 _session.engine().unregister_port (*i);
 209         }
 210
 211         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 212                 _session.engine().unregister_port (*i);
 213         }
 214
 215         m_meter_connection.disconnect();
 216
 217         delete _meter;
 218         delete _panner;
 219 }
 220
 221 void
 222 IO::silence (nframes_t nframes, nframes_t offset)
 223 {
 224         /* io_lock, not taken: function must be called from Session::process() calltree */
 225
 226         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 227                 i->get_buffer(nframes,offset).silence (nframes, offset);
 228         }
 229 }
 230
 231 /** Deliver bufs to the IO's output ports
 232  *
 233  * This function should automatically do whatever it necessary to correctly deliver bufs
 234  * to the outputs, eg applying gain or pan or whatever else needs to be done.
 235  */
 236 void
 237 IO::deliver_output (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
 238 {
 239         // FIXME: type specific code doesn't actually need to be here, it will go away in time
 240
 241         /* ********** AUDIO ********** */
 242
 243         // Apply gain if gain automation isn't playing
 244         if ( ! apply_gain_automation) {
 245
 246                 gain_t dg = _gain; // desired gain
 247
 248                 {
 249                         Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
 250
 251                         if (dm.locked()) {
 252                                 dg = _desired_gain;
 253                         }
 254
 255                 }
 256
 257                 if (dg != _gain || dg != 1.0) {
 258                         Amp::run_in_place(bufs, nframes, _gain, dg, _phase_invert);
 259                         _gain = dg;
 260                 }
 261         }
 262
 263         /* do this so that any processing that comes after deliver_outputs()
 264            can use the output buffers.
 265         */
 266
 267         output_buffers().attach_buffers (_outputs, nframes, offset);
 268
 269         // Use the panner to distribute audio to output port buffers
 270
 271         if (0 && _panner && _panner->npanners() && !_panner->bypassed()) {
 272
 273                 /* blech .. we shouldn't be creating and tearing this down every process()
 274                    cycle. XXX fix me to not waste cycles and do memory allocation etc.
 275                 */
 276
 277                 _panner->run_out_of_place(bufs, output_buffers(), start_frame, end_frame, nframes, offset);
 278
 279         } else {
 280
 281                 /* do a 1:1 copy of data to output ports */
 282
 283                 if (bufs.count().n_audio() > 0 && _outputs.count().n_audio () > 0) {
 284                         copy_to_outputs (bufs, DataType::AUDIO, nframes, offset);
 285                 }
 286                 if (bufs.count().n_midi() > 0 && _outputs.count().n_midi () > 0) {
 287                         copy_to_outputs (bufs, DataType::MIDI, nframes, offset);
 288                 }
 289         }
 290 }
 291
 292 void
 293 IO::copy_to_outputs (BufferSet& bufs, DataType type, nframes_t nframes, nframes_t offset)
 294 {
 295         // Copy any buffers 1:1 to outputs
 296
 297         PortSet::iterator o = _outputs.begin(type);
 298         BufferSet::iterator i = bufs.begin(type);
 299         BufferSet::iterator prev = i;
 300
 301         while (i != bufs.end(type) && o != _outputs.end (type)) {
 302
 303                 Buffer& port_buffer (o->get_buffer (nframes, offset));
 304                 port_buffer.read_from (*i, nframes, offset);
 305
 306                 prev = i;
 307                 ++i;
 308                 ++o;
 309         }
 310
 311         /* extra outputs get a copy of the last buffer */
 312
 313         while (o != _outputs.end(type)) {
 314                 Buffer& port_buffer (o->get_buffer (nframes, offset));
 315                 port_buffer.read_from(*prev, nframes, offset);
 316                 ++o;
 317         }
 318 }
 319
 320 void
 321 IO::collect_input (BufferSet& outs, nframes_t nframes, nframes_t offset)
 322 {
 323         assert(outs.available() >= n_inputs());
 324
 325         if (n_inputs() == ChanCount::ZERO)
 326                 return;
 327
 328         outs.set_count(n_inputs());
 329
 330         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 331
 332                 BufferSet::iterator o = outs.begin(*t);
 333                 PortSet::iterator e = _inputs.end (*t);
 334                 for (PortSet::iterator i = _inputs.begin(*t); i != e; ++i, ++o) {
 335                         Buffer& b (i->get_buffer (nframes,offset));
 336                         o->read_from (b, nframes, offset);
 337                 }
 338
 339         }
 340 }
 341
 342 void
 343 IO::just_meter_input (nframes_t start_frame, nframes_t end_frame,
 344                       nframes_t nframes, nframes_t offset)
 345 {
 346         BufferSet& bufs = _session.get_scratch_buffers (n_inputs());
 347
 348         collect_input (bufs, nframes, offset);
 349
 350         _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
 351 }
 352
 353
 354 void
 355 IO::check_bundles_connected_to_inputs ()
 356 {
 357         check_bundles (_bundles_connected_to_inputs, inputs());
 358 }
 359
 360 void
 361 IO::check_bundles_connected_to_outputs ()
 362 {
 363         check_bundles (_bundles_connected_to_outputs, outputs());
 364 }
 365
 366 void
 367 IO::check_bundles (std::vector<UserBundleInfo>& list, const PortSet& ports)
 368 {
 369         std::vector<UserBundleInfo> new_list;
 370
 371         for (std::vector<UserBundleInfo>::iterator i = list.begin(); i != list.end(); ++i) {
 372
 373                 uint32_t const N = i->bundle->nchannels ();
 374
 375                 if (ports.num_ports (default_type()) < N) {
 376                         continue;
 377                 }
 378
 379                 bool ok = true;
 380
 381                 for (uint32_t j = 0; j < N; ++j) {
 382                         /* Every port on bundle channel j must be connected to our input j */
 383                         Bundle::PortList const pl = i->bundle->channel_ports (j);
 384                         for (uint32_t k = 0; k < pl.size(); ++k) {
 385                                 if (ports.port(j)->connected_to (pl[k]) == false) {
 386                                         ok = false;
 387                                         break;
 388                                 }
 389                         }
 390
 391                         if (ok == false) {
 392                                 break;
 393                         }
 394                 }
 395
 396                 if (ok) {
 397                         new_list.push_back (*i);
 398                 } else {
 399                         i->configuration_changed.disconnect ();
 400                         i->ports_changed.disconnect ();
 401                 }
 402         }
 403
 404         list = new_list;
 405 }
 406
 407
 408 int
 409 IO::disconnect_input (Port* our_port, string other_port, void* src)
 410 {
 411         if (other_port.length() == 0 || our_port == 0) {
 412                 return 0;
 413         }
 414
 415         {
 416                 BLOCK_PROCESS_CALLBACK ();
 417
 418                 {
 419                         Glib::Mutex::Lock lm (io_lock);
 420
 421                         /* check that our_port is really one of ours */
 422
 423                         if ( ! _inputs.contains(our_port)) {
 424                                 return -1;
 425                         }
 426
 427                         /* disconnect it from the source */
 428
 429                         if (_session.engine().disconnect (other_port, our_port->name())) {
 430                                 error << string_compose(_("IO: cannot disconnect input port %1 from %2"), our_port->name(), other_port) << endmsg;
 431                                 return -1;
 432                         }
 433
 434                         check_bundles_connected_to_inputs ();
 435                 }
 436         }
 437
 438         input_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 439         _session.set_dirty ();
 440
 441         return 0;
 442 }
 443
 444 int
 445 IO::connect_input (Port* our_port, string other_port, void* src)
 446 {
 447         if (other_port.length() == 0 || our_port == 0) {
 448                 return 0;
 449         }
 450
 451         {
 452                 BLOCK_PROCESS_CALLBACK ();
 453
 454                 {
 455                         Glib::Mutex::Lock lm (io_lock);
 456
 457                         /* check that our_port is really one of ours */
 458
 459                         if ( ! _inputs.contains(our_port) ) {
 460                                 return -1;
 461                         }
 462
 463                         /* connect it to the source */
 464
 465                         if (_session.engine().connect (other_port, our_port->name())) {
 466                                 return -1;
 467                         }
 468                 }
 469         }
 470
 471         input_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 472         _session.set_dirty ();
 473         return 0;
 474 }
 475
 476 int
 477 IO::disconnect_output (Port* our_port, string other_port, void* src)
 478 {
 479         if (other_port.length() == 0 || our_port == 0) {
 480                 return 0;
 481         }
 482
 483         {
 484                 BLOCK_PROCESS_CALLBACK ();
 485
 486                 {
 487                         Glib::Mutex::Lock lm (io_lock);
 488
 489                         /* check that our_port is really one of ours */
 490
 491                         if ( ! _outputs.contains(our_port) ) {
 492                                 return -1;
 493                         }
 494
 495                         /* disconnect it from the destination */
 496
 497                         if (_session.engine().disconnect (our_port->name(), other_port)) {
 498                                 error << string_compose(_("IO: cannot disconnect output port %1 from %2"), our_port->name(), other_port) << endmsg;
 499                                 return -1;
 500                         }
 501
 502                         check_bundles_connected_to_outputs ();
 503                 }
 504         }
 505
 506         output_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 507         _session.set_dirty ();
 508         return 0;
 509 }
 510
 511 int
 512 IO::connect_output (Port* our_port, string other_port, void* src)
 513 {
 514         if (other_port.length() == 0 || our_port == 0) {
 515                 return 0;
 516         }
 517
 518         {
 519                 BLOCK_PROCESS_CALLBACK ();
 520
 521
 522                 {
 523                         Glib::Mutex::Lock lm (io_lock);
 524
 525                         /* check that our_port is really one of ours */
 526
 527                         if ( ! _outputs.contains(our_port) ) {
 528                                 return -1;
 529                         }
 530
 531                         /* connect it to the destination */
 532
 533                         if (_session.engine().connect (our_port->name(), other_port)) {
 534                                 return -1;
 535                         }
 536                 }
 537         }
 538
 539         output_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 540         _session.set_dirty ();
 541         return 0;
 542 }
 543
 544 int
 545 IO::set_input (Port* other_port, void* src)
 546 {
 547         /* this removes all but one ports, and connects that one port
 548            to the specified source.
 549         */
 550
 551         if (_input_minimum.n_total() > 1) {
 552                 /* sorry, you can't do this */
 553                 return -1;
 554         }
 555
 556         if (other_port == 0) {
 557                 if (_input_minimum == ChanCount::ZERO) {
 558                         return ensure_inputs (ChanCount::ZERO, false, true, src);
 559                 } else {
 560                         return -1;
 561                 }
 562         }
 563
 564         if (ensure_inputs (ChanCount(other_port->type(), 1), true, true, src)) {
 565                 return -1;
 566         }
 567
 568         return connect_input (_inputs.port(0), other_port->name(), src);
 569 }
 570
 571 int
 572 IO::remove_output_port (Port* port, void* src)
 573 {
 574         IOChange change (NoChange);
 575
 576         {
 577                 BLOCK_PROCESS_CALLBACK ();
 578
 579
 580                 {
 581                         Glib::Mutex::Lock lm (io_lock);
 582
 583                         if (n_outputs() <= _output_minimum) {
 584                                 /* sorry, you can't do this */
 585                                 return -1;
 586                         }
 587
 588                         if (_outputs.remove(port)) {
 589                                 change = IOChange (change|ConfigurationChanged);
 590
 591                                 if (port->connected()) {
 592                                         change = IOChange (change|ConnectionsChanged);
 593                                 }
 594
 595                                 _session.engine().unregister_port (*port);
 596                                 check_bundles_connected_to_outputs ();
 597
 598                                 setup_peak_meters ();
 599                                 reset_panner ();
 600                         }
 601                 }
 602
 603                 PortCountChanged (n_outputs()); /* EMIT SIGNAL */
 604         }
 605
 606         if (change == ConfigurationChanged) {
 607                 setup_bundles_for_inputs_and_outputs ();
 608         }
 609
 610         if (change != NoChange) {
 611                 output_changed (change, src);
 612                 _session.set_dirty ();
 613                 return 0;
 614         }
 615
 616         return -1;
 617 }
 618
 619 /** Add an output port.
 620  *
 621  * @param destination Name of input port to connect new port to.
 622  * @param src Source for emitted ConfigurationChanged signal.
 623  * @param type Data type of port.  Default value (NIL) will use this IO's default type.
 624  */
 625 int
 626 IO::add_output_port (string destination, void* src, DataType type)
 627 {
 628         Port* our_port;
 629
 630         if (type == DataType::NIL)
 631                 type = _default_type;
 632
 633         {
 634                 BLOCK_PROCESS_CALLBACK ();
 635
 636
 637                 {
 638                         Glib::Mutex::Lock lm (io_lock);
 639
 640                         if (n_outputs() >= _output_maximum) {
 641                                 return -1;
 642                         }
 643
 644                         /* Create a new output port */
 645
 646                         string portname = build_legal_port_name (type, false);
 647
 648                         if ((our_port = _session.engine().register_output_port (type, portname, _public_ports)) == 0) {
 649                                 error << string_compose(_("IO: cannot register output port %1"), portname) << endmsg;
 650                                 return -1;
 651                         }
 652
 653                         _outputs.add (our_port);
 654                         setup_peak_meters ();
 655                         reset_panner ();
 656                 }
 657
 658                 PortCountChanged (n_outputs()); /* EMIT SIGNAL */
 659         }
 660
 661         if (destination.length()) {
 662                 if (_session.engine().connect (our_port->name(), destination)) {
 663                         return -1;
 664                 }
 665         }
 666
 667         // pan_changed (src); /* EMIT SIGNAL */
 668         output_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 669         setup_bundles_for_inputs_and_outputs ();
 670         _session.set_dirty ();
 671
 672         return 0;
 673 }
 674
 675 int
 676 IO::remove_input_port (Port* port, void* src)
 677 {
 678         IOChange change (NoChange);
 679
 680         {
 681                 BLOCK_PROCESS_CALLBACK ();
 682
 683
 684                 {
 685                         Glib::Mutex::Lock lm (io_lock);
 686
 687                         if (n_inputs() <= _input_minimum) {
 688                                 /* sorry, you can't do this */
 689                                 return -1;
 690                         }
 691
 692                         if (_inputs.remove(port)) {
 693                                 change = IOChange (change|ConfigurationChanged);
 694
 695                                 if (port->connected()) {
 696                                         change = IOChange (change|ConnectionsChanged);
 697                                 }
 698
 699                                 _session.engine().unregister_port (*port);
 700                                 check_bundles_connected_to_inputs ();
 701
 702                                 setup_peak_meters ();
 703                                 reset_panner ();
 704                         }
 705                 }
 706
 707                 PortCountChanged (n_inputs ()); /* EMIT SIGNAL */
 708         }
 709
 710         if (change == ConfigurationChanged) {
 711                 setup_bundles_for_inputs_and_outputs ();
 712         }
 713
 714         if (change != NoChange) {
 715                 input_changed (change, src);
 716                 _session.set_dirty ();
 717                 return 0;
 718         }
 719
 720         return -1;
 721 }
 722
 723
 724 /** Add an input port.
 725  *
 726  * @param type Data type of port.  The appropriate port type, and @ref Port will be created.
 727  * @param destination Name of input port to connect new port to.
 728  * @param src Source for emitted ConfigurationChanged signal.
 729  */
 730 int
 731 IO::add_input_port (string source, void* src, DataType type)
 732 {
 733         Port* our_port;
 734
 735         if (type == DataType::NIL)
 736                 type = _default_type;
 737
 738         {
 739                 BLOCK_PROCESS_CALLBACK ();
 740
 741                 {
 742                         Glib::Mutex::Lock lm (io_lock);
 743
 744                         if (_input_maximum.get(type) >= 0 && n_inputs().get (type) >= _input_maximum.get (type)) {
 745                                 return -1;
 746                         }
 747
 748                         /* Create a new input port */
 749
 750                         string portname = build_legal_port_name (type, true);
 751
 752                         if ((our_port = _session.engine().register_input_port (type, portname, _public_ports)) == 0) {
 753                                 error << string_compose(_("IO: cannot register input port %1"), portname) << endmsg;
 754                                 return -1;
 755                         }
 756
 757                         _inputs.add (our_port);
 758                         setup_peak_meters ();
 759                         reset_panner ();
 760                 }
 761
 762                 PortCountChanged (n_inputs()); /* EMIT SIGNAL */
 763         }
 764
 765         if (source.length()) {
 766
 767                 if (_session.engine().connect (source, our_port->name())) {
 768                         return -1;
 769                 }
 770         }
 771
 772         // pan_changed (src); /* EMIT SIGNAL */
 773         input_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 774         setup_bundles_for_inputs_and_outputs ();
 775         _session.set_dirty ();
 776
 777         return 0;
 778 }
 779
 780 int
 781 IO::disconnect_inputs (void* src)
 782 {
 783         {
 784                 BLOCK_PROCESS_CALLBACK ();
 785
 786                 {
 787                         Glib::Mutex::Lock lm (io_lock);
 788
 789                         for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 790                                 _session.engine().disconnect (*i);
 791                         }
 792
 793                         check_bundles_connected_to_inputs ();
 794                 }
 795         }
 796
 797         input_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 798
 799         return 0;
 800 }
 801
 802 int
 803 IO::disconnect_outputs (void* src)
 804 {
 805         {
 806                 BLOCK_PROCESS_CALLBACK ();
 807
 808                 {
 809                         Glib::Mutex::Lock lm (io_lock);
 810
 811                         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 812                                 _session.engine().disconnect (*i);
 813                         }
 814
 815                         check_bundles_connected_to_outputs ();
 816                 }
 817         }
 818
 819         output_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 820         _session.set_dirty ();
 821
 822         return 0;
 823 }
 824
 825 bool
 826 IO::ensure_inputs_locked (ChanCount count, bool clear, void* src)
 827 {
 828         Port* input_port = 0;
 829         bool  changed    = false;
 830
 831
 832         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 833
 834                 const size_t n = count.get(*t);
 835
 836                 /* remove unused ports */
 837                 for (size_t i = n_inputs().get(*t); i > n; --i) {
 838                         input_port = _inputs.port(*t, i-1);
 839
 840                         assert(input_port);
 841                         _inputs.remove(input_port);
 842                         _session.engine().unregister_port (*input_port);
 843
 844                         changed = true;
 845                 }
 846
 847                 /* create any necessary new ports */
 848                 while (n_inputs().get(*t) < n) {
 849
 850                         string portname = build_legal_port_name (*t, true);
 851
 852                         try {
 853
 854                                 if ((input_port = _session.engine().register_input_port (*t, portname, _public_ports)) == 0) {
 855                                         error << string_compose(_("IO: cannot register input port %1"), portname) << endmsg;
 856                                         return -1;
 857                                 }
 858                         }
 859
 860                         catch (AudioEngine::PortRegistrationFailure& err) {
 861                                 setup_peak_meters ();
 862                                 reset_panner ();
 863                                 /* pass it on */
 864                                 throw AudioEngine::PortRegistrationFailure();
 865                         }
 866
 867                         _inputs.add (input_port);
 868                         changed = true;
 869                 }
 870         }
 871
 872         if (changed) {
 873                 check_bundles_connected_to_inputs ();
 874                 setup_peak_meters ();
 875                 reset_panner ();
 876                 PortCountChanged (n_inputs()); /* EMIT SIGNAL */
 877                 _session.set_dirty ();
 878         }
 879
 880         if (clear) {
 881                 /* disconnect all existing ports so that we get a fresh start */
 882                 for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 883                         _session.engine().disconnect (*i);
 884                 }
 885         }
 886
 887         return changed;
 888 }
 889
 890 int
 891 IO::ensure_io (ChanCount in, ChanCount out, bool clear, void* src)
 892 {
 893         bool in_changed     = false;
 894         bool out_changed    = false;
 895         bool need_pan_reset = false;
 896
 897         in = min (_input_maximum, in);
 898
 899         out = min (_output_maximum, out);
 900
 901         if (in == n_inputs() && out == n_outputs() && !clear) {
 902                 return 0;
 903         }
 904
 905         {
 906                 BLOCK_PROCESS_CALLBACK ();
 907                 Glib::Mutex::Lock lm (io_lock);
 908
 909                 Port* port;
 910
 911                 if (n_outputs() != out) {
 912                         need_pan_reset = true;
 913                 }
 914
 915                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 916
 917                         const size_t nin = in.get(*t);
 918                         const size_t nout = out.get(*t);
 919
 920                         Port* output_port = 0;
 921                         Port* input_port = 0;
 922
 923                         /* remove unused output ports */
 924                         for (size_t i = n_outputs().get(*t); i > nout; --i) {
 925                                 output_port = _outputs.port(*t, i-1);
 926
 927                                 assert(output_port);
 928                                 _outputs.remove(output_port);
 929                                 _session.engine().unregister_port (*output_port);
 930
 931                                 out_changed = true;
 932                         }
 933
 934                         /* remove unused input ports */
 935                         for (size_t i = n_inputs().get(*t); i > nin; --i) {
 936                                 input_port = _inputs.port(*t, i-1);
 937
 938                                 assert(input_port);
 939                                 _inputs.remove(input_port);
 940                                 _session.engine().unregister_port (*input_port);
 941
 942                                 in_changed = true;
 943                         }
 944
 945                         /* create any necessary new input ports */
 946
 947                         while (n_inputs().get(*t) < nin) {
 948
 949                                 string portname = build_legal_port_name (*t, true);
 950
 951                                 try {
 952                                         if ((port = _session.engine().register_input_port (*t, portname, _public_ports)) == 0) {
 953                                                 error << string_compose(_("IO: cannot register input port %1"), portname) << endmsg;
 954                                                 return -1;
 955                                         }
 956                                 }
 957
 958                                 catch (AudioEngine::PortRegistrationFailure& err) {
 959                                         setup_peak_meters ();
 960                                         reset_panner ();
 961                                         /* pass it on */
 962                                         throw AudioEngine::PortRegistrationFailure();
 963                                 }
 964
 965                                 _inputs.add (port);
 966                                 in_changed = true;
 967                         }
 968
 969                         /* create any necessary new output ports */
 970
 971                         while (n_outputs().get(*t) < nout) {
 972
 973                                 string portname = build_legal_port_name (*t, false);
 974
 975                                 try {
 976                                         if ((port = _session.engine().register_output_port (*t, portname, _public_ports)) == 0) {
 977                                                 error << string_compose(_("IO: cannot register output port %1"), portname) << endmsg;
 978                                                 return -1;
 979                                         }
 980                                 }
 981
 982                                 catch (AudioEngine::PortRegistrationFailure& err) {
 983                                         setup_peak_meters ();
 984                                         reset_panner ();
 985                                         /* pass it on */
 986                                         throw AudioEngine::PortRegistrationFailure ();
 987                                 }
 988
 989                                 _outputs.add (port);
 990                                 out_changed = true;
 991                         }
 992                 }
 993
 994                 if (clear) {
 995
 996                         /* disconnect all existing ports so that we get a fresh start */
 997
 998                         for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 999                                 _session.engine().disconnect (*i);
1000                         }
1001
1002                         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
1003                                 _session.engine().disconnect (*i);
1004                         }
1005                 }
1006
1007                 if (in_changed || out_changed) {
1008                         setup_peak_meters ();
1009                         reset_panner ();
1010                 }
1011         }
1012
1013         if (out_changed) {
1014                 check_bundles_connected_to_outputs ();
1015                 output_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
1016         }
1017
1018         if (in_changed) {
1019                 check_bundles_connected_to_inputs ();
1020                 input_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
1021         }
1022
1023         if (in_changed || out_changed) {
1024                 PortCountChanged (max (n_outputs(), n_inputs())); /* EMIT SIGNAL */
1025                 setup_bundles_for_inputs_and_outputs ();
1026                 _session.set_dirty ();
1027         }
1028
1029         return 0;
1030 }
1031
1032 int
1033 IO::ensure_inputs (ChanCount count, bool clear, bool lockit, void* src)
1034 {
1035         bool changed = false;
1036
1037         count = min (_input_maximum, count);
1038
1039         if (count == n_inputs() && !clear) {
1040                 return 0;
1041         }
1042
1043         if (lockit) {
1044                 BLOCK_PROCESS_CALLBACK ();
1045                 Glib::Mutex::Lock im (io_lock);
1046                 changed = ensure_inputs_locked (count, clear, src);
1047         } else {
1048                 changed = ensure_inputs_locked (count, clear, src);
1049         }
1050
1051         if (changed) {
1052                 input_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
1053                 setup_bundles_for_inputs_and_outputs ();
1054                 _session.set_dirty ();
1055         }
1056         return 0;
1057 }
1058
1059 bool
1060 IO::ensure_outputs_locked (ChanCount count, bool clear, void* src)
1061 {
1062         Port* output_port    = 0;
1063         bool  changed        = false;
1064         bool  need_pan_reset = false;
1065
1066         if (n_outputs() != count) {
1067                 need_pan_reset = true;
1068         }
1069
1070         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1071
1072                 const size_t n = count.get(*t);
1073
1074                 /* remove unused ports */
1075                 for (size_t i = n_outputs().get(*t); i > n; --i) {
1076                         output_port = _outputs.port(*t, i-1);
1077
1078                         assert(output_port);
1079                         _outputs.remove(output_port);
1080                         _session.engine().unregister_port (*output_port);
1081
1082                         changed = true;
1083                 }
1084
1085                 /* create any necessary new ports */
1086                 while (n_outputs().get(*t) < n) {
1087
1088                         string portname = build_legal_port_name (*t, false);
1089
1090                         if ((output_port = _session.engine().register_output_port (*t, portname, _public_ports)) == 0) {
1091                                 error << string_compose(_("IO: cannot register output port %1"), portname) << endmsg;
1092                                 return -1;
1093                         }
1094
1095                         _outputs.add (output_port);
1096                         changed = true;
1097                         setup_peak_meters ();
1098
1099                         if (need_pan_reset) {
1100                                 reset_panner ();
1101                         }
1102                 }
1103         }
1104
1105         if (changed) {
1106                 check_bundles_connected_to_outputs ();
1107                 PortCountChanged (n_outputs()); /* EMIT SIGNAL */
1108                 _session.set_dirty ();
1109         }
1110
1111         if (clear) {
1112                 /* disconnect all existing ports so that we get a fresh start */
1113                 for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
1114                         _session.engine().disconnect (*i);
1115                 }
1116         }
1117
1118         return changed;
1119 }
1120
1121 int
1122 IO::ensure_outputs (ChanCount count, bool clear, bool lockit, void* src)
1123 {
1124         bool changed = false;
1125
1126         if (_output_maximum < ChanCount::INFINITE) {
1127                 count = min (_output_maximum, count);
1128                 if (count == n_outputs() && !clear) {
1129                         return 0;
1130                 }
1131         }
1132
1133         /* XXX caller should hold io_lock, but generally doesn't */
1134
1135         if (lockit) {
1136                 BLOCK_PROCESS_CALLBACK ();
1137                 Glib::Mutex::Lock im (io_lock);
1138                 changed = ensure_outputs_locked (count, clear, src);
1139         } else {
1140                 changed = ensure_outputs_locked (count, clear, src);
1141         }
1142
1143         if (changed) {
1144                  output_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
1145                  setup_bundles_for_inputs_and_outputs ();
1146         }
1147
1148         return 0;
1149 }
1150
1151 gain_t
1152 IO::effective_gain () const
1153 {
1154         if (_gain_control->automation_playback()) {
1155                 return _gain_control->get_value();
1156         } else {
1157                 return _desired_gain;
1158         }
1159 }
1160
1161 void
1162 IO::reset_panner ()
1163 {
1164         if (panners_legal) {
1165                 if (!no_panner_reset) {
1166                         _panner->reset (n_outputs().n_audio(), pans_required());
1167                 }
1168         } else {
1169                 panner_legal_c.disconnect ();
1170                 panner_legal_c = PannersLegal.connect (mem_fun (*this, &IO::panners_became_legal));
1171         }
1172 }
1173
1174 int
1175 IO::panners_became_legal ()
1176 {
1177         _panner->reset (n_outputs().n_audio(), pans_required());
1178         _panner->load (); // automation
1179         panner_legal_c.disconnect ();
1180         return 0;
1181 }
1182
1183 void
1184 IO::defer_pan_reset ()
1185 {
1186         no_panner_reset = true;
1187 }
1188
1189 void
1190 IO::allow_pan_reset ()
1191 {
1192         no_panner_reset = false;
1193         reset_panner ();
1194 }
1195
1196
1197 XMLNode&
1198 IO::get_state (void)
1199 {
1200         return state (true);
1201 }
1202
1203 XMLNode&
1204 IO::state (bool full_state)
1205 {
1206         XMLNode* node = new XMLNode (state_node_name);
1207         char buf[64];
1208         string str;
1209         vector<string>::iterator ci;
1210         int n;
1211         LocaleGuard lg (X_("POSIX"));
1212         Glib::Mutex::Lock lm (io_lock);
1213
1214         node->add_property("name", _name);
1215         id().print (buf, sizeof (buf));
1216         node->add_property("id", buf);
1217
1218         for (
1219           std::vector<UserBundleInfo>::iterator i = _bundles_connected_to_inputs.begin();
1220           i != _bundles_connected_to_inputs.end();
1221           ++i
1222           )
1223         {
1224                 XMLNode* n = new XMLNode ("InputBundle");
1225                 n->add_property ("name", i->bundle->name ());
1226                 node->add_child_nocopy (*n);
1227         }
1228
1229         for (
1230           std::vector<UserBundleInfo>::iterator i = _bundles_connected_to_outputs.begin();
1231           i != _bundles_connected_to_outputs.end();
1232           ++i
1233           )
1234         {
1235                 XMLNode* n = new XMLNode ("OutputBundle");
1236                 n->add_property ("name", i->bundle->name ());
1237                 node->add_child_nocopy (*n);
1238         }
1239
1240         str = "";
1241
1242         for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
1243
1244                 vector<string> connections;
1245
1246                 if (i->get_connections (connections)) {
1247
1248                         str += '{';
1249
1250                         for (n = 0, ci = connections.begin(); ci != connections.end(); ++ci, ++n) {
1251                                 if (n) {
1252                                         str += ',';
1253                                 }
1254
1255                                 /* if its a connection to our own port,
1256                                    return only the port name, not the
1257                                    whole thing. this allows connections
1258                                    to be re-established even when our
1259                                    client name is different.
1260                                 */
1261
1262                                 str += _session.engine().make_port_name_relative (*ci);
1263                         }
1264
1265                         str += '}';
1266
1267                 } else {
1268                         str += "{}";
1269                 }
1270         }
1271
1272         node->add_property ("inputs", str);
1273
1274         str = "";
1275
1276         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
1277
1278                 vector<string> connections;
1279
1280                 if (i->get_connections (connections)) {
1281
1282                         str += '{';
1283
1284                         for (n = 0, ci = connections.begin(); ci != connections.end(); ++ci, ++n) {
1285                                 if (n) {
1286                                         str += ',';
1287                                 }
1288
1289                                 str += _session.engine().make_port_name_relative (*ci);
1290                         }
1291
1292                         str += '}';
1293
1294                 } else {
1295                         str += "{}";
1296                 }
1297         }
1298
1299         node->add_property ("outputs", str);
1300
1301         node->add_child_nocopy (_panner->state (full_state));
1302         node->add_child_nocopy (_gain_control->get_state ());
1303
1304         snprintf (buf, sizeof(buf), "%2.12f", gain());
1305         node->add_property ("gain", buf);
1306
1307         /* To make backwards compatibility a bit easier, write ChanCount::INFINITE to the session file
1308            as -1.
1309         */
1310
1311         int const in_max = _input_maximum == ChanCount::INFINITE ? -1 : _input_maximum.get(_default_type);
1312         int const out_max = _output_maximum == ChanCount::INFINITE ? -1 : _output_maximum.get(_default_type);
1313
1314         snprintf (buf, sizeof(buf)-1, "%d,%d,%d,%d", _input_minimum.get(_default_type), in_max, _output_minimum.get(_default_type), out_max);
1315
1316         node->add_property ("iolimits", buf);
1317
1318         /* automation */
1319
1320         if (full_state)
1321                 node->add_child_nocopy (get_automation_state());
1322
1323         return *node;
1324 }
1325
1326 int
1327 IO::set_state (const XMLNode& node)
1328 {
1329         const XMLProperty* prop;
1330         XMLNodeConstIterator iter;
1331         LocaleGuard lg (X_("POSIX"));
1332
1333         /* force use of non-localized representation of decimal point,
1334            since we use it a lot in XML files and so forth.
1335         */
1336
1337         if (node.name() != state_node_name) {
1338                 error << string_compose(_("incorrect XML node \"%1\" passed to IO object"), node.name()) << endmsg;
1339                 return -1;
1340         }
1341
1342         if ((prop = node.property ("name")) != 0) {
1343                 _name = prop->value();
1344                 /* used to set panner name with this, but no more */
1345         }
1346
1347         if ((prop = node.property ("id")) != 0) {
1348                 _id = prop->value ();
1349         }
1350
1351         int in_min = -1;
1352         int in_max = -1;
1353         int out_min = -1;
1354         int out_max = -1;
1355
1356         if ((prop = node.property ("iolimits")) != 0) {
1357                 sscanf (prop->value().c_str(), "%d,%d,%d,%d",
1358                         &in_min, &in_max, &out_min, &out_max);
1359
1360                 /* Correct for the difference between the way we write things to session files and the
1361                    way things are described by ChanCount; see comments in io.h about what the different
1362                    ChanCount values mean. */
1363
1364                 if (in_min < 0) {
1365                         _input_minimum = ChanCount::ZERO;
1366                 } else {
1367                         _input_minimum = ChanCount (_default_type, in_min);
1368                 }
1369
1370                 if (in_max < 0) {
1371                         _input_maximum = ChanCount::INFINITE;
1372                 } else {
1373                         _input_maximum = ChanCount (_default_type, in_max);
1374                 }
1375
1376                 if (out_min < 0) {
1377                         _output_minimum = ChanCount::ZERO;
1378                 } else {
1379                         _output_minimum = ChanCount (_default_type, out_min);
1380                 }
1381
1382                 if (out_max < 0) {
1383                         _output_maximum = ChanCount::INFINITE;
1384                 } else {
1385                         _output_maximum = ChanCount (_default_type, out_max);
1386                 }
1387         }
1388
1389         if ((prop = node.property ("gain")) != 0) {
1390                 set_gain (atof (prop->value().c_str()), this);
1391                 _gain = _desired_gain;
1392         }
1393
1394         if ((prop = node.property ("automation-state")) != 0 || (prop = node.property ("automation-style")) != 0) {
1395                 /* old school automation handling */
1396         }
1397
1398         for (iter = node.children().begin(); iter != node.children().end(); ++iter) {
1399
1400                 // Old school Panner.
1401                 if ((*iter)->name() == "Panner") {
1402                         if (_panner == 0) {
1403                                 _panner = new Panner (_name, _session);
1404                         }
1405                         _panner->set_state (**iter);
1406                 }
1407
1408                 if ((*iter)->name() == "Processor") {
1409                         if ((*iter)->property ("type") && ((*iter)->property ("type")->value() == "panner" ) ) {
1410                                 if (_panner == 0) {
1411                                         _panner = new Panner (_name, _session);
1412                                 }
1413                                 _panner->set_state (**iter);
1414                         }
1415                 }
1416
1417                 if ((*iter)->name() == X_("Automation")) {
1418
1419                         set_automation_state (*(*iter), Evoral::Parameter(GainAutomation));
1420                 }
1421
1422                 if ((*iter)->name() == X_("controllable")) {
1423                         if ((prop = (*iter)->property("name")) != 0 && prop->value() == "gaincontrol") {
1424                                 _gain_control->set_state (**iter);
1425                         }
1426                 }
1427         }
1428
1429         if (ports_legal) {
1430
1431                 if (create_ports (node)) {
1432                         return -1;
1433                 }
1434
1435         } else {
1436
1437                 port_legal_c = PortsLegal.connect (mem_fun (*this, &IO::ports_became_legal));
1438         }
1439
1440         if( !_panner )
1441             _panner = new Panner( _name, _session );
1442         if (panners_legal) {
1443                 reset_panner ();
1444         } else {
1445                 panner_legal_c = PannersLegal.connect (mem_fun (*this, &IO::panners_became_legal));
1446         }
1447
1448         if (connecting_legal) {
1449
1450                 if (make_connections (node)) {
1451                         return -1;
1452                 }
1453
1454         } else {
1455
1456                 connection_legal_c = ConnectingLegal.connect (mem_fun (*this, &IO::connecting_became_legal));
1457         }
1458
1459         if (!ports_legal || !connecting_legal) {
1460                 pending_state_node = new XMLNode (node);
1461         }
1462
1463         return 0;
1464 }
1465
1466 int
1467 IO::load_automation (string path)
1468 {
1469         string fullpath;
1470         ifstream in;
1471         char line[128];
1472         uint32_t linecnt = 0;
1473         float version;
1474         LocaleGuard lg (X_("POSIX"));
1475
1476         fullpath = Glib::build_filename(_session.automation_dir(), path);
1477
1478         in.open (fullpath.c_str());
1479
1480         if (!in) {
1481                 fullpath = Glib::build_filename(_session.automation_dir(), _session.snap_name() + '-' + path);
1482
1483                 in.open (fullpath.c_str());
1484
1485                 if (!in) {
1486                         error << string_compose(_("%1: cannot open automation event file \"%2\""), _name, fullpath) << endmsg;
1487                         return -1;
1488                 }
1489         }
1490
1491         clear_automation ();
1492
1493         while (in.getline (line, sizeof(line), '\n')) {
1494                 char type;
1495                 nframes_t when;
1496                 double value;
1497
1498                 if (++linecnt == 1) {
1499                         if (memcmp (line, "version", 7) == 0) {
1500                                 if (sscanf (line, "version %f", &version) != 1) {
1501                                         error << string_compose(_("badly formed version number in automation event file \"%1\""), path) << endmsg;
1502                                         return -1;
1503                                 }
1504                         } else {
1505                                 error << string_compose(_("no version information in automation event file \"%1\""), path) << endmsg;
1506                                 return -1;
1507                         }
1508
1509                         continue;
1510                 }
1511
1512                 if (sscanf (line, "%c %" PRIu32 " %lf", &type, &when, &value) != 3) {
1513                         warning << string_compose(_("badly formatted automation event record at line %1 of %2 (ignored)"), linecnt, path) << endmsg;
1514                         continue;
1515                 }
1516
1517                 switch (type) {
1518                 case 'g':
1519                         _gain_control->list()->fast_simple_add (when, value);
1520                         break;
1521
1522                 case 's':
1523                         break;
1524
1525                 case 'm':
1526                         break;
1527
1528                 case 'p':
1529                         /* older (pre-1.0) versions of ardour used this */
1530                         break;
1531
1532                 default:
1533                         warning << _("dubious automation event found (and ignored)") << endmsg;
1534                 }
1535         }
1536
1537         return 0;
1538 }
1539
1540 int
1541 IO::connecting_became_legal ()
1542 {
1543         int ret;
1544
1545         if (pending_state_node == 0) {
1546                 fatal << _("IO::connecting_became_legal() called without a pending state node") << endmsg;
1547                 /*NOTREACHED*/
1548                 return -1;
1549         }
1550
1551         connection_legal_c.disconnect ();
1552
1553         ret = make_connections (*pending_state_node);
1554
1555         if (ports_legal) {
1556                 delete pending_state_node;
1557                 pending_state_node = 0;
1558         }
1559
1560         return ret;
1561 }
1562 int
1563 IO::ports_became_legal ()
1564 {
1565         int ret;
1566
1567         if (pending_state_node == 0) {
1568                 fatal << _("IO::ports_became_legal() called without a pending state node") << endmsg;
1569                 /*NOTREACHED*/
1570                 return -1;
1571         }
1572
1573         port_legal_c.disconnect ();
1574
1575         ret = create_ports (*pending_state_node);
1576
1577         if (connecting_legal) {
1578                 delete pending_state_node;
1579                 pending_state_node = 0;
1580         }
1581
1582         return ret;
1583 }
1584
1585 boost::shared_ptr<Bundle>
1586 IO::find_possible_bundle (const string &desired_name, const string &default_name, const string &bundle_type_name)
1587 {
1588         static const string digits = "0123456789";
1589
1590         boost::shared_ptr<Bundle> c = _session.bundle_by_name (desired_name);
1591
1592         if (!c) {
1593                 int bundle_number, mask;
1594                 string possible_name;
1595                 bool stereo = false;
1596                 string::size_type last_non_digit_pos;
1597
1598                 error << string_compose(_("Unknown bundle \"%1\" listed for %2 of %3"), desired_name, bundle_type_name, _name)
1599                       << endmsg;
1600
1601                 // find numeric suffix of desired name
1602                 bundle_number = 0;
1603
1604                 last_non_digit_pos = desired_name.find_last_not_of(digits);
1605
1606                 if (last_non_digit_pos != string::npos) {
1607                         stringstream s;
1608                         s << desired_name.substr(last_non_digit_pos);
1609                         s >> bundle_number;
1610                 }
1611
1612                 // see if it's a stereo connection e.g. "in 3+4"
1613
1614                 if (last_non_digit_pos > 1 && desired_name[last_non_digit_pos] == '+') {
1615                         int left_bundle_number = 0;
1616                         string::size_type left_last_non_digit_pos;
1617
1618                         left_last_non_digit_pos = desired_name.find_last_not_of(digits, last_non_digit_pos-1);
1619
1620                         if (left_last_non_digit_pos != string::npos) {
1621                                 stringstream s;
1622                                 s << desired_name.substr(left_last_non_digit_pos, last_non_digit_pos-1);
1623                                 s >> left_bundle_number;
1624
1625                                 if (left_bundle_number > 0 && left_bundle_number + 1 == bundle_number) {
1626                                         bundle_number--;
1627                                         stereo = true;
1628                                 }
1629                         }
1630                 }
1631
1632                 // make 0-based
1633                 if (bundle_number)
1634                         bundle_number--;
1635
1636                 // find highest set bit
1637                 mask = 1;
1638                 while ((mask <= bundle_number) && (mask <<= 1));
1639
1640                 // "wrap" bundle number into largest possible power of 2
1641                 // that works...
1642
1643                 while (mask) {
1644
1645                         if (bundle_number & mask) {
1646                                 bundle_number &= ~mask;
1647
1648                                 stringstream s;
1649                                 s << default_name << " " << bundle_number + 1;
1650
1651                                 if (stereo) {
1652                                         s << "+" << bundle_number + 2;
1653                                 }
1654
1655                                 possible_name = s.str();
1656
1657                                 if ((c = _session.bundle_by_name (possible_name)) != 0) {
1658                                         break;
1659                                 }
1660                         }
1661                         mask >>= 1;
1662                 }
1663                 if (c) {
1664                         info << string_compose (_("Bundle %1 was not available - \"%2\" used instead"), desired_name, possible_name)
1665                              << endmsg;
1666                 } else {
1667                         error << string_compose(_("No %1 bundles available as a replacement"), bundle_type_name)
1668                               << endmsg;
1669                 }
1670
1671         }
1672
1673         return c;
1674
1675 }
1676
1677 int
1678 IO::create_ports (const XMLNode& node)
1679 {
1680         XMLProperty const * prop;
1681         uint32_t num_inputs = 0;
1682         uint32_t num_outputs = 0;
1683
1684         if ((prop = node.property ("input-connection")) != 0) {
1685
1686                 boost::shared_ptr<Bundle> c = find_possible_bundle (prop->value(), _("in"), _("input"));
1687
1688                 if (!c) {
1689                         return -1;
1690                 }
1691
1692                 num_inputs = c->nchannels();
1693
1694         } else if ((prop = node.property ("inputs")) != 0) {
1695
1696                 num_inputs = count (prop->value().begin(), prop->value().end(), '{');
1697         }
1698
1699         if ((prop = node.property ("output-connection")) != 0) {
1700
1701                 boost::shared_ptr<Bundle> c = find_possible_bundle(prop->value(), _("out"), _("output"));
1702
1703                 if (!c) {
1704                         return -1;
1705                 }
1706
1707                 num_outputs = c->nchannels ();
1708
1709         } else if ((prop = node.property ("outputs")) != 0) {
1710
1711                 num_outputs = count (prop->value().begin(), prop->value().end(), '{');
1712         }
1713
1714         no_panner_reset = true;
1715
1716         if (ensure_io (ChanCount (_default_type, num_inputs),
1717                        ChanCount (_default_type, num_outputs),
1718                        true, this)) {
1719
1720                 error << string_compose(_("%1: cannot create I/O ports"), _name) << endmsg;
1721                 return -1;
1722         }
1723
1724         no_panner_reset = false;
1725
1726         set_deferred_state ();
1727
1728         PortsCreated();
1729         return 0;
1730 }
1731
1732
1733 int
1734 IO::make_connections (const XMLNode& node)
1735 {
1736
1737         const XMLProperty* prop;
1738
1739         if ((prop = node.property ("input-connection")) != 0) {
1740                 boost::shared_ptr<Bundle> c = find_possible_bundle (prop->value(), _("in"), _("input"));
1741
1742                 if (!c) {
1743                         return -1;
1744                 }
1745
1746                 connect_input_ports_to_bundle (c, this);
1747
1748         } else if ((prop = node.property ("inputs")) != 0) {
1749                 if (set_inputs (prop->value())) {
1750                         error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg;
1751                         return -1;
1752                 }
1753         }
1754
1755         if ((prop = node.property ("output-connection")) != 0) {
1756                 boost::shared_ptr<Bundle> c = find_possible_bundle (prop->value(), _("out"), _("output"));
1757
1758                 if (!c) {
1759                         return -1;
1760                 }
1761
1762                 connect_output_ports_to_bundle (c, this);
1763
1764         } else if ((prop = node.property ("outputs")) != 0) {
1765                 if (set_outputs (prop->value())) {
1766                         error << string_compose(_("improper output channel list in XML node (%1)"), prop->value()) << endmsg;
1767                         return -1;
1768                 }
1769         }
1770
1771         for (XMLNodeConstIterator i = node.children().begin(); i != node.children().end(); ++i) {
1772
1773                 if ((*i)->name() == "InputBundle") {
1774                         XMLProperty const * prop = (*i)->property ("name");
1775                         if (prop) {
1776                                 boost::shared_ptr<Bundle> b = find_possible_bundle (prop->value(), _("in"), _("input"));
1777                                 if (b) {
1778                                         connect_input_ports_to_bundle (b, this);
1779                                 }
1780                         }
1781
1782                 } else if ((*i)->name() == "OutputBundle") {
1783                         XMLProperty const * prop = (*i)->property ("name");
1784                         if (prop) {
1785                                 boost::shared_ptr<Bundle> b = find_possible_bundle (prop->value(), _("out"), _("output"));
1786                                 if (b) {
1787                                         connect_output_ports_to_bundle (b, this);
1788                                 }
1789                         }
1790                 }
1791         }
1792
1793         return 0;
1794 }
1795
1796 int
1797 IO::set_inputs (const string& str)
1798 {
1799         vector<string> ports;
1800         int i;
1801         int n;
1802         uint32_t nports;
1803
1804         if ((nports = count (str.begin(), str.end(), '{')) == 0) {
1805                 return 0;
1806         }
1807
1808         // FIXME: audio-only
1809         if (ensure_inputs (ChanCount(DataType::AUDIO, nports), true, true, this)) {
1810                 return -1;
1811         }
1812
1813         string::size_type start, end, ostart;
1814
1815         ostart = 0;
1816         start = 0;
1817         end = 0;
1818         i = 0;
1819
1820         while ((start = str.find_first_of ('{', ostart)) != string::npos) {
1821                 start += 1;
1822
1823                 if ((end = str.find_first_of ('}', start)) == string::npos) {
1824                         error << string_compose(_("IO: badly formed string in XML node for inputs \"%1\""), str) << endmsg;
1825                         return -1;
1826                 }
1827
1828                 if ((n = parse_io_string (str.substr (start, end - start), ports)) < 0) {
1829                         error << string_compose(_("bad input string in XML node \"%1\""), str) << endmsg;
1830
1831                         return -1;
1832
1833                 } else if (n > 0) {
1834
1835                         for (int x = 0; x < n; ++x) {
1836                                 connect_input (input (i), ports[x], this);
1837                         }
1838                 }
1839
1840                 ostart = end+1;
1841                 i++;
1842         }
1843
1844         return 0;
1845 }
1846
1847 int
1848 IO::set_outputs (const string& str)
1849 {
1850         vector<string> ports;
1851         int i;
1852         int n;
1853         uint32_t nports;
1854
1855         if ((nports = count (str.begin(), str.end(), '{')) == 0) {
1856                 return 0;
1857         }
1858
1859         // FIXME: audio-only
1860         if (ensure_outputs (ChanCount(DataType::AUDIO, nports), true, true, this)) {
1861                 return -1;
1862         }
1863
1864         string::size_type start, end, ostart;
1865
1866         ostart = 0;
1867         start = 0;
1868         end = 0;
1869         i = 0;
1870
1871         while ((start = str.find_first_of ('{', ostart)) != string::npos) {
1872                 start += 1;
1873
1874                 if ((end = str.find_first_of ('}', start)) == string::npos) {
1875                         error << string_compose(_("IO: badly formed string in XML node for outputs \"%1\""), str) << endmsg;
1876                         return -1;
1877                 }
1878
1879                 if ((n = parse_io_string (str.substr (start, end - start), ports)) < 0) {
1880                         error << string_compose(_("IO: bad output string in XML node \"%1\""), str) << endmsg;
1881
1882                         return -1;
1883
1884                 } else if (n > 0) {
1885
1886                         for (int x = 0; x < n; ++x) {
1887                                 connect_output (output (i), ports[x], this);
1888                         }
1889                 }
1890
1891                 ostart = end+1;
1892                 i++;
1893         }
1894
1895         return 0;
1896 }
1897
1898 int
1899 IO::parse_io_string (const string& str, vector<string>& ports)
1900 {
1901         string::size_type pos, opos;
1902
1903         if (str.length() == 0) {
1904                 return 0;
1905         }
1906
1907         pos = 0;
1908         opos = 0;
1909
1910         ports.clear ();
1911
1912         while ((pos = str.find_first_of (',', opos)) != string::npos) {
1913                 ports.push_back (str.substr (opos, pos - opos));
1914                 opos = pos + 1;
1915         }
1916
1917         if (opos < str.length()) {
1918                 ports.push_back (str.substr(opos));
1919         }
1920
1921         return ports.size();
1922 }
1923
1924 int
1925 IO::parse_gain_string (const string& str, vector<string>& ports)
1926 {
1927         string::size_type pos, opos;
1928
1929         pos = 0;
1930         opos = 0;
1931         ports.clear ();
1932
1933         while ((pos = str.find_first_of (',', opos)) != string::npos) {
1934                 ports.push_back (str.substr (opos, pos - opos));
1935                 opos = pos + 1;
1936         }
1937
1938         if (opos < str.length()) {
1939                 ports.push_back (str.substr(opos));
1940         }
1941
1942         return ports.size();
1943 }
1944
1945 bool
1946 IO::set_name (const string& requested_name)
1947 {
1948         if (requested_name == _name) {
1949                 return true;
1950         }
1951
1952         string name;
1953         Route *rt;
1954         if ( (rt = dynamic_cast<Route *>(this))) {
1955                 name = Route::ensure_track_or_route_name(requested_name, _session);
1956         } else {
1957                 name = requested_name;
1958         }
1959
1960
1961         /* replace all colons in the name. i wish we didn't have to do this */
1962
1963         if (replace_all (name, ":", "-")) {
1964                 warning << _("you cannot use colons to name objects with I/O connections") << endmsg;
1965         }
1966
1967         for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
1968                 string current_name = i->name();
1969                 current_name.replace (current_name.find (_name), _name.length(), name);
1970                 i->set_name (current_name);
1971         }
1972
1973         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
1974                 string current_name = i->name();
1975                 current_name.replace (current_name.find (_name), _name.length(), name);
1976                 i->set_name (current_name);
1977         }
1978
1979         bool const r = SessionObject::set_name(name);
1980
1981         setup_bundles_for_inputs_and_outputs ();
1982
1983         return r;
1984 }
1985
1986 void
1987 IO::set_input_minimum (ChanCount n)
1988 {
1989         _input_minimum = n;
1990 }
1991
1992 void
1993 IO::set_input_maximum (ChanCount n)
1994 {
1995         _input_maximum = n;
1996 }
1997
1998 void
1999 IO::set_output_minimum (ChanCount n)
2000 {
2001         _output_minimum = n;
2002 }
2003
2004 void
2005 IO::set_output_maximum (ChanCount n)
2006 {
2007         _output_maximum = n;
2008 }
2009
2010 void
2011 IO::set_port_latency (nframes_t nframes)
2012 {
2013         Glib::Mutex::Lock lm (io_lock);
2014
2015         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
2016                 i->set_latency (nframes);
2017         }
2018 }
2019
2020 nframes_t
2021 IO::output_latency () const
2022 {
2023         nframes_t max_latency;
2024         nframes_t latency;
2025
2026         max_latency = 0;
2027
2028         /* io lock not taken - must be protected by other means */
2029
2030         for (PortSet::const_iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
2031                 if ((latency = i->total_latency ()) > max_latency) {
2032                         max_latency = latency;
2033                 }
2034         }
2035
2036         return max_latency;
2037 }
2038
2039 nframes_t
2040 IO::input_latency () const
2041 {
2042         nframes_t max_latency;
2043         nframes_t latency;
2044
2045         max_latency = 0;
2046
2047         /* io lock not taken - must be protected by other means */
2048
2049         for (PortSet::const_iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
2050                 if ((latency = i->total_latency ()) > max_latency) {
2051                         max_latency = latency;
2052                 }
2053         }
2054
2055         return max_latency;
2056 }
2057
2058 int
2059 IO::connect_input_ports_to_bundle (boost::shared_ptr<Bundle> c, void* src)
2060 {
2061         {
2062                 BLOCK_PROCESS_CALLBACK ();
2063                 Glib::Mutex::Lock lm2 (io_lock);
2064
2065                 /* Connect to the bundle, not worrying about any connections
2066                    that are already made. */
2067
2068                 uint32_t cnt = c->nchannels ();
2069
2070                 for (uint32_t n = 0; n < cnt; ++n) {
2071                         const Bundle::PortList& pl = c->channel_ports (n);
2072
2073                         for (Bundle::PortList::const_iterator i = pl.begin(); i != pl.end(); ++i) {
2074
2075                           if (!_inputs.port(n)->connected_to (*i)) {
2076
2077                                         if (_session.engine().connect (*i, _inputs.port(n)->name())) {
2078                                                 return -1;
2079                                         }
2080                                 }
2081
2082                         }
2083                 }
2084
2085                 /* If this is a UserBundle, make a note of what we've done */
2086
2087                 boost::shared_ptr<UserBundle> ub = boost::dynamic_pointer_cast<UserBundle> (c);
2088                 if (ub) {
2089
2090                         /* See if we already know about this one */
2091                         std::vector<UserBundleInfo>::iterator i = _bundles_connected_to_inputs.begin();
2092                         while (i != _bundles_connected_to_inputs.end() && i->bundle != ub) {
2093                                 ++i;
2094                         }
2095
2096                         if (i == _bundles_connected_to_inputs.end()) {
2097                                 /* We don't, so make a note */
2098                                 _bundles_connected_to_inputs.push_back (UserBundleInfo (this, ub));
2099                         }
2100                 }
2101         }
2102
2103         input_changed (IOChange (ConfigurationChanged|ConnectionsChanged), src); /* EMIT SIGNAL */
2104         return 0;
2105 }
2106
2107 int
2108 IO::connect_output_ports_to_bundle (boost::shared_ptr<Bundle> c, void* src)
2109 {
2110         {
2111                 BLOCK_PROCESS_CALLBACK ();
2112                 Glib::Mutex::Lock lm2 (io_lock);
2113
2114                 /* Connect to the bundle, not worrying about any connections
2115                    that are already made. */
2116
2117                 uint32_t cnt = c->nchannels ();
2118
2119                 for (uint32_t n = 0; n < cnt; ++n) {
2120
2121                         const Bundle::PortList& pl = c->channel_ports (n);
2122
2123                         for (Bundle::PortList::const_iterator i = pl.begin(); i != pl.end(); ++i) {
2124
2125                                 if (!_outputs.port(n)->connected_to (*i)) {
2126
2127                                         if (_session.engine().connect (_outputs.port(n)->name(), *i)) {
2128                                                 return -1;
2129                                         }
2130                                 }
2131                         }
2132                 }
2133
2134                 /* If this is a UserBundle, make a note of what we've done */
2135
2136                 boost::shared_ptr<UserBundle> ub = boost::dynamic_pointer_cast<UserBundle> (c);
2137                 if (ub) {
2138
2139                         /* See if we already know about this one */
2140                         std::vector<UserBundleInfo>::iterator i = _bundles_connected_to_outputs.begin();
2141                         while (i != _bundles_connected_to_outputs.end() && i->bundle != ub) {
2142                                 ++i;
2143                         }
2144
2145                         if (i == _bundles_connected_to_outputs.end()) {
2146                                 /* We don't, so make a note */
2147                                 _bundles_connected_to_outputs.push_back (UserBundleInfo (this, ub));
2148                         }
2149                 }
2150         }
2151
2152         output_changed (IOChange (ConnectionsChanged|ConfigurationChanged), src); /* EMIT SIGNAL */
2153
2154         return 0;
2155 }
2156
2157 int
2158 IO::disable_connecting ()
2159 {
2160         connecting_legal = false;
2161         return 0;
2162 }
2163
2164 int
2165 IO::enable_connecting ()
2166 {
2167         connecting_legal = true;
2168         return ConnectingLegal ();
2169 }
2170
2171 int
2172 IO::disable_ports ()
2173 {
2174         ports_legal = false;
2175         return 0;
2176 }
2177
2178 int
2179 IO::enable_ports ()
2180 {
2181         ports_legal = true;
2182         return PortsLegal ();
2183 }
2184
2185 int
2186 IO::disable_panners (void)
2187 {
2188         panners_legal = false;
2189         return 0;
2190 }
2191
2192 int
2193 IO::reset_panners ()
2194 {
2195         panners_legal = true;
2196         return PannersLegal ();
2197 }
2198
2199 void
2200 IO::bundle_configuration_changed ()
2201 {
2202         //XXX
2203 //      connect_input_ports_to_bundle (_input_bundle, this);
2204 }
2205
2206 void
2207 IO::bundle_ports_changed (int ignored)
2208 {
2209         //XXX
2210 //      connect_output_ports_to_bundle (_output_bundle, this);
2211 }
2212
2213 void
2214 IO::GainControl::set_value (float val)
2215 {
2216         // max gain at about +6dB (10.0 ^ ( 6 dB * 0.05))
2217         if (val > 1.99526231f)
2218                 val = 1.99526231f;
2219
2220         _io->set_gain (val, this);
2221
2222         AutomationControl::set_value(val);
2223 }
2224
2225 float
2226 IO::GainControl::get_value (void) const
2227 {
2228         return AutomationControl::get_value();
2229 }
2230
2231 void
2232 IO::setup_peak_meters()
2233 {
2234         ChanCount max_streams = std::max (_inputs.count(), _outputs.count());
2235         _meter->configure_io (max_streams, max_streams);
2236 }
2237
2238 /**
2239     Update the peak meters.
2240
2241     The meter signal lock is taken to prevent modification of the
2242     Meter signal while updating the meters, taking the meter signal
2243     lock prior to taking the io_lock ensures that all IO will remain
2244     valid while metering.
2245 */
2246 void
2247 IO::update_meters()
2248 {
2249         Glib::Mutex::Lock guard (m_meter_signal_lock);
2250         Meter(); /* EMIT SIGNAL */
2251 }
2252
2253 void
2254 IO::meter ()
2255 {
2256         // FIXME: Ugly.  Meter should manage the lock, if it's necessary
2257
2258         Glib::Mutex::Lock lm (io_lock); // READER: meter thread.
2259         _meter->meter();
2260 }
2261
2262 void
2263 IO::clear_automation ()
2264 {
2265         data().clear (); // clears gain automation
2266         _panner->data().clear();
2267 }
2268
2269 void
2270 IO::set_parameter_automation_state (Evoral::Parameter param, AutoState state)
2271 {
2272         // XXX: would be nice to get rid of this special hack
2273
2274         if (param.type() == GainAutomation) {
2275
2276                 bool changed = false;
2277
2278                 {
2279                         Glib::Mutex::Lock lm (control_lock());
2280
2281                         boost::shared_ptr<AutomationList> gain_auto
2282                                 = boost::dynamic_pointer_cast<AutomationList>(_gain_control->list());
2283
2284                         if (state != gain_auto->automation_state()) {
2285                                 changed = true;
2286                                 _last_automation_snapshot = 0;
2287                                 gain_auto->set_automation_state (state);
2288
2289                                 if (state != Off) {
2290                                         // FIXME: shouldn't this use Curve?
2291                                         set_gain (gain_auto->eval (_session.transport_frame()), this);
2292                                 }
2293                         }
2294                 }
2295
2296                 if (changed) {
2297                         _session.set_dirty ();
2298                 }
2299
2300         } else {
2301                 AutomatableControls::set_parameter_automation_state(param, state);
2302         }
2303 }
2304
2305 void
2306 IO::inc_gain (gain_t factor, void *src)
2307 {
2308         if (_desired_gain == 0.0f)
2309                 set_gain (0.000001f + (0.000001f * factor), src);
2310         else
2311                 set_gain (_desired_gain + (_desired_gain * factor), src);
2312 }
2313
2314 void
2315 IO::set_gain (gain_t val, void *src)
2316 {
2317         // max gain at about +6dB (10.0 ^ ( 6 dB * 0.05))
2318         if (val > 1.99526231f) {
2319                 val = 1.99526231f;
2320         }
2321
2322         cerr << "set desired gain to " << val << " when curgain = " << _gain_control->get_value () << endl;
2323
2324         if (src != _gain_control.get()) {
2325                 _gain_control->set_value(val);
2326                 // bit twisty, this will come back and call us again
2327                 // (this keeps control in sync with reality)
2328                 return;
2329         }
2330
2331         {
2332                 Glib::Mutex::Lock dm (declick_lock);
2333                 _desired_gain = val;
2334         }
2335
2336         if (_session.transport_stopped()) {
2337                 // _gain = val;
2338         }
2339
2340         /*
2341         if (_session.transport_stopped() && src != 0 && src != this && _gain_control->automation_write()) {
2342                 _gain_control->list()->add (_session.transport_frame(), val);
2343
2344         }
2345         */
2346
2347         _session.set_dirty();
2348 }
2349
2350 void
2351 IO::start_pan_touch (uint32_t which)
2352 {
2353         if (which < _panner->npanners()) {
2354                 (*_panner).pan_control(which)->start_touch();
2355         }
2356 }
2357
2358 void
2359 IO::end_pan_touch (uint32_t which)
2360 {
2361         if (which < _panner->npanners()) {
2362                 (*_panner).pan_control(which)->stop_touch();
2363         }
2364
2365 }
2366
2367 void
2368 IO::automation_snapshot (nframes_t now, bool force)
2369 {
2370         AutomatableControls::automation_snapshot (now, force);
2371         // XXX: This seems to be wrong.
2372         // drobilla: shouldnt automation_snapshot for panner be called
2373         //           "automagically" because its an Automatable now ?
2374         //
2375         //           we could dump this whole method then. <3
2376
2377         if (_last_automation_snapshot > now || (now - _last_automation_snapshot) > _automation_interval) {
2378                 _panner->automation_snapshot (now, force);
2379         }
2380
2381         _panner->automation_snapshot (now, force);
2382         _last_automation_snapshot = now;
2383 }
2384
2385 void
2386 IO::transport_stopped (nframes_t frame)
2387 {
2388         _gain_control->list()->reposition_for_rt_add (frame);
2389
2390         if (_gain_control->automation_state() != Off) {
2391
2392                 /* the src=0 condition is a special signal to not propagate
2393                    automation gain changes into the mix group when locating.
2394                 */
2395
2396                 // FIXME: shouldn't this use Curve?
2397                 set_gain (_gain_control->list()->eval (frame), 0);
2398         }
2399
2400         _panner->transport_stopped (frame);
2401 }
2402
2403 string
2404 IO::build_legal_port_name (DataType type, bool in)
2405 {
2406         const int name_size = jack_port_name_size();
2407         int limit;
2408         string suffix;
2409         int maxports;
2410
2411         if (type == DataType::AUDIO) {
2412                 suffix = _("audio");
2413         } else if (type == DataType::MIDI) {
2414                 suffix = _("midi");
2415         } else {
2416                 throw unknown_type();
2417         }
2418
2419         if (in) {
2420                 suffix += _("_in");
2421                 maxports = _input_maximum.get(type);
2422         } else {
2423                 suffix += _("_out");
2424                 maxports = _output_maximum.get(type);
2425         }
2426
2427         if (maxports == 1) {
2428                 // allow space for the slash + the suffix
2429                 limit = name_size - _session.engine().client_name().length() - (suffix.length() + 1);
2430                 char buf[name_size+1];
2431                 snprintf (buf, name_size+1, ("%.*s/%s"), limit, _name.c_str(), suffix.c_str());
2432                 return string (buf);
2433         }
2434
2435         // allow up to 4 digits for the output port number, plus the slash, suffix and extra space
2436
2437         limit = name_size - _session.engine().client_name().length() - (suffix.length() + 5);
2438
2439         char buf1[name_size+1];
2440         char buf2[name_size+1];
2441
2442         snprintf (buf1, name_size+1, ("%.*s/%s"), limit, _name.c_str(), suffix.c_str());
2443
2444         int port_number;
2445
2446         if (in) {
2447                 port_number = find_input_port_hole (buf1);
2448         } else {
2449                 port_number = find_output_port_hole (buf1);
2450         }
2451
2452         snprintf (buf2, name_size+1, "%s %d", buf1, port_number);
2453
2454         return string (buf2);
2455 }
2456
2457 int32_t
2458 IO::find_input_port_hole (const char* base)
2459 {
2460         /* CALLER MUST HOLD IO LOCK */
2461
2462         uint32_t n;
2463
2464         if (_inputs.empty()) {
2465                 return 1;
2466         }
2467
2468         /* we only allow up to 4 characters for the port number
2469          */
2470
2471         for (n = 1; n < 9999; ++n) {
2472                 char buf[jack_port_name_size()];
2473                 PortSet::iterator i = _inputs.begin();
2474
2475                 snprintf (buf, jack_port_name_size(), _("%s %u"), base, n);
2476
2477                 for ( ; i != _inputs.end(); ++i) {
2478                         if (i->name() == buf) {
2479                                 break;
2480                         }
2481                 }
2482
2483                 if (i == _inputs.end()) {
2484                         break;
2485                 }
2486         }
2487         return n;
2488 }
2489
2490 int32_t
2491 IO::find_output_port_hole (const char* base)
2492 {
2493         /* CALLER MUST HOLD IO LOCK */
2494
2495         uint32_t n;
2496
2497         if (_outputs.empty()) {
2498                 return 1;
2499         }
2500
2501         /* we only allow up to 4 characters for the port number
2502          */
2503
2504         for (n = 1; n < 9999; ++n) {
2505                 char buf[jack_port_name_size()];
2506                 PortSet::iterator i = _outputs.begin();
2507
2508                 snprintf (buf, jack_port_name_size(), _("%s %u"), base, n);
2509
2510                 for ( ; i != _outputs.end(); ++i) {
2511                         if (i->name() == buf) {
2512                                 break;
2513                         }
2514                 }
2515
2516                 if (i == _outputs.end()) {
2517                         break;
2518                 }
2519         }
2520
2521         return n;
2522 }
2523
2524 void
2525 IO::set_active (bool yn)
2526 {
2527         _active = yn;
2528          active_changed(); /* EMIT SIGNAL */
2529 }
2530
2531 AudioPort*
2532 IO::audio_input(uint32_t n) const
2533 {
2534         return dynamic_cast<AudioPort*>(input(n));
2535 }
2536
2537 AudioPort*
2538 IO::audio_output(uint32_t n) const
2539 {
2540         return dynamic_cast<AudioPort*>(output(n));
2541 }
2542
2543 MidiPort*
2544 IO::midi_input(uint32_t n) const
2545 {
2546         return dynamic_cast<MidiPort*>(input(n));
2547 }
2548
2549 MidiPort*
2550 IO::midi_output(uint32_t n) const
2551 {
2552         return dynamic_cast<MidiPort*>(output(n));
2553 }
2554
2555 void
2556 IO::set_phase_invert (bool yn, void *src)
2557 {
2558         if (_phase_invert != yn) {
2559                 _phase_invert = yn;
2560                 //  phase_invert_changed (src); /* EMIT SIGNAL */
2561         }
2562 }
2563
2564 void
2565 IO::set_denormal_protection (bool yn, void *src)
2566 {
2567         if (_denormal_protection != yn) {
2568                 _denormal_protection = yn;
2569                 //  denormal_protection_changed (src); /* EMIT SIGNAL */
2570         }
2571 }
2572
2573 void
2574 IO::update_port_total_latencies ()
2575 {
2576         /* io_lock, not taken: function must be called from Session::process() calltree */
2577
2578         for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
2579                 _session.engine().update_total_latency (*i);
2580         }
2581
2582         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
2583                 _session.engine().update_total_latency (*i);
2584         }
2585 }
2586
2587
2588 /**
2589  *  Setup bundles that describe our inputs and outputs.
2590  */
2591
2592 void
2593 IO::setup_bundles_for_inputs_and_outputs ()
2594 {
2595         char buf[32];
2596
2597         _bundle_for_inputs->remove_channels ();
2598         _bundle_for_outputs->remove_channels ();
2599
2600         snprintf(buf, sizeof (buf), _("%s in"), _name.c_str());
2601         _bundle_for_inputs->set_name (buf);
2602         uint32_t const ni = inputs().num_ports();
2603         for (uint32_t i = 0; i < ni; ++i) {
2604                 _bundle_for_inputs->add_channel (bundle_channel_name (i, ni));
2605                 _bundle_for_inputs->set_port (i, _session.engine().make_port_name_non_relative (inputs().port(i)->name()));
2606         }
2607
2608         snprintf(buf, sizeof (buf), _("%s out"), _name.c_str());
2609         _bundle_for_outputs->set_name (buf);
2610         uint32_t const no = outputs().num_ports();
2611         for (uint32_t i = 0; i < no; ++i) {
2612                 _bundle_for_outputs->add_channel (bundle_channel_name (i, no));
2613                 _bundle_for_outputs->set_port (i, _session.engine().make_port_name_non_relative (outputs().port(i)->name()));
2614         }
2615 }
2616
2617
2618 /**
2619  *  Create and setup bundles that describe our inputs and outputs.
2620  */
2621
2622 void
2623 IO::create_bundles_for_inputs_and_outputs ()
2624 {
2625         _bundle_for_inputs = boost::shared_ptr<Bundle> (new Bundle (true));
2626         _bundle_for_outputs = boost::shared_ptr<Bundle> (new Bundle (false));
2627         setup_bundles_for_inputs_and_outputs ();
2628 }
2629
2630 /** @return Bundles connected to our inputs */
2631 BundleList
2632 IO::bundles_connected_to_inputs ()
2633 {
2634         BundleList bundles;
2635
2636         /* User bundles */
2637         for (std::vector<UserBundleInfo>::iterator i = _bundles_connected_to_inputs.begin(); i != _bundles_connected_to_inputs.end(); ++i) {
2638                 bundles.push_back (i->bundle);
2639         }
2640
2641         /* Normal bundles */
2642         boost::shared_ptr<ARDOUR::BundleList> b = _session.bundles ();
2643         for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
2644                 if ((*i)->ports_are_outputs() == false || (*i)->nchannels() != n_inputs().n_total()) {
2645                         continue;
2646                 }
2647
2648                 for (uint32_t j = 0; j < n_inputs().n_total(); ++j) {
2649
2650                         Bundle::PortList const& pl = (*i)->channel_ports (j);
2651                         if (!pl.empty() && input(j)->connected_to (pl[0])) {
2652                                 bundles.push_back (*i);
2653                         }
2654
2655                 }
2656         }
2657
2658         return bundles;
2659 }
2660
2661
2662 /* @return Bundles connected to our outputs */
2663 BundleList
2664 IO::bundles_connected_to_outputs ()
2665 {
2666         BundleList bundles;
2667
2668         /* User bundles */
2669         for (std::vector<UserBundleInfo>::iterator i = _bundles_connected_to_outputs.begin(); i != _bundles_connected_to_outputs.end(); ++i) {
2670                 bundles.push_back (i->bundle);
2671         }
2672
2673         /* Auto bundles */
2674         boost::shared_ptr<ARDOUR::BundleList> b = _session.bundles ();
2675         for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
2676                 if ((*i)->ports_are_inputs() == false || (*i)->nchannels() != n_outputs().n_total()) {
2677                         continue;
2678                 }
2679
2680                 for (uint32_t j = 0; j < n_outputs().n_total(); ++j) {
2681
2682                         Bundle::PortList const& pl = (*i)->channel_ports (j);
2683
2684                         if (!pl.empty() && output(j)->connected_to (pl[0])) {
2685                                 bundles.push_back (*i);
2686                         }
2687                 }
2688         }
2689
2690         return bundles;
2691 }
2692
2693
2694 IO::UserBundleInfo::UserBundleInfo (IO* io, boost::shared_ptr<UserBundle> b)
2695 {
2696         bundle = b;
2697         configuration_changed = b->ConfigurationChanged.connect (
2698                 sigc::mem_fun (*io, &IO::bundle_configuration_changed)
2699                 );
2700         ports_changed = b->PortsChanged.connect (
2701                 sigc::mem_fun (*io, &IO::bundle_ports_changed)
2702                 );
2703 }
2704
2705 void
2706 IO::prepare_inputs (nframes_t nframes, nframes_t offset)
2707 {
2708         /* io_lock, not taken: function must be called from Session::process() calltree */
2709 }
2710
2711 void
2712 IO::flush_outputs (nframes_t nframes, nframes_t offset)
2713 {
2714         /* io_lock, not taken: function must be called from Session::process() calltree */
2715         for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
2716
2717                 /* Only run cycle_start() on output ports, because
2718                    inputs must be done in the correct processing order,
2719                    which requires interleaving with route processing.
2720                 */
2721
2722                 (*i).flush_buffers (nframes, offset);
2723         }
2724
2725 }
2726
2727 std::string
2728 IO::bundle_channel_name (uint32_t c, uint32_t n) const
2729 {
2730         char buf[32];
2731
2732         switch (n) {
2733         case 1:
2734                 return _("mono");
2735         case 2:
2736                 return c == 0 ? _("L") : _("R");
2737         default:
2738                 snprintf (buf, sizeof(buf), _("%d"), (c + 1));
2739                 return buf;
2740         }
2741
2742         return "";
2743 }
2744
2745