libs/ardour/io.cc

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