libs/ardour/plugin_insert.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 #ifdef WAF_BUILD
  21 #include "libardour-config.h"
  22 #endif
  23
  24 #include <string>
  25
  26 #include "pbd/failed_constructor.h"
  27 #include "pbd/xml++.h"
  28 #include "pbd/convert.h"
  29
  30 #include "ardour/audio_buffer.h"
  31 #include "ardour/automation_list.h"
  32 #include "ardour/buffer_set.h"
  33 #include "ardour/debug.h"
  34 #include "ardour/event_type_map.h"
  35 #include "ardour/ladspa_plugin.h"
  36 #include "ardour/luaproc.h"
  37 #include "ardour/plugin.h"
  38 #include "ardour/plugin_insert.h"
  39 #include "ardour/port.h"
  40
  41 #ifdef LV2_SUPPORT
  42 #include "ardour/lv2_plugin.h"
  43 #endif
  44
  45 #ifdef WINDOWS_VST_SUPPORT
  46 #include "ardour/windows_vst_plugin.h"
  47 #endif
  48
  49 #ifdef LXVST_SUPPORT
  50 #include "ardour/lxvst_plugin.h"
  51 #endif
  52
  53 #ifdef AUDIOUNIT_SUPPORT
  54 #include "ardour/audio_unit.h"
  55 #endif
  56
  57 #include "ardour/session.h"
  58 #include "ardour/types.h"
  59
  60 #include "i18n.h"
  61
  62 using namespace std;
  63 using namespace ARDOUR;
  64 using namespace PBD;
  65
  66 const string PluginInsert::port_automation_node_name = "PortAutomation";
  67
  68 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
  69         : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
  70         , _signal_analysis_collected_nframes(0)
  71         , _signal_analysis_collect_nframes_max(0)
  72         , _configured (false)
  73         , _no_inplace (false)
  74         , _strict_io (false)
  75         , _custom_cfg (false)
  76         , _maps_from_state (false)
  77 {
  78         /* the first is the master */
  79
  80         if (plug) {
  81                 add_plugin (plug);
  82                 create_automatable_parameters ();
  83                 const ChanCount& sc (sidechain_input_pins ());
  84                 if (sc.n_audio () > 0) {
  85                         add_sidechain (sc.n_audio ());
  86                 }
  87         }
  88 }
  89
  90 PluginInsert::~PluginInsert ()
  91 {
  92 }
  93
  94 void
  95 PluginInsert::set_strict_io (bool b)
  96 {
  97         bool changed = _strict_io != b;
  98         _strict_io = b;
  99         if (changed) {
 100                 PluginConfigChanged (); /* EMIT SIGNAL */
 101         }
 102 }
 103
 104 bool
 105 PluginInsert::set_count (uint32_t num)
 106 {
 107         bool require_state = !_plugins.empty();
 108
 109         /* this is a bad idea.... we shouldn't do this while active.
 110            only a route holding their redirect_lock should be calling this
 111         */
 112
 113         if (num == 0) {
 114                 return false;
 115         } else if (num > _plugins.size()) {
 116                 uint32_t diff = num - _plugins.size();
 117
 118                 for (uint32_t n = 0; n < diff; ++n) {
 119                         boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
 120                         add_plugin (p);
 121
 122                         if (require_state) {
 123                                 XMLNode& state = _plugins[0]->get_state ();
 124                                 p->set_state (state, Stateful::loading_state_version);
 125                         }
 126
 127                         if (active ()) {
 128                                 p->activate ();
 129                         }
 130                 }
 131                 PluginConfigChanged (); /* EMIT SIGNAL */
 132
 133         } else if (num < _plugins.size()) {
 134                 uint32_t diff = _plugins.size() - num;
 135                 for (uint32_t n= 0; n < diff; ++n) {
 136                         _plugins.pop_back();
 137                 }
 138                 PluginConfigChanged (); /* EMIT SIGNAL */
 139         }
 140
 141         return true;
 142 }
 143
 144
 145 void
 146 PluginInsert::set_outputs (const ChanCount& c)
 147 {
 148         bool changed = (_custom_out != c) && _custom_cfg;
 149         _custom_out = c;
 150         if (changed) {
 151                 PluginConfigChanged (); /* EMIT SIGNAL */
 152         }
 153 }
 154
 155 void
 156 PluginInsert::set_custom_cfg (bool b)
 157 {
 158         bool changed = _custom_cfg != b;
 159         _custom_cfg = b;
 160         if (changed) {
 161                 PluginConfigChanged (); /* EMIT SIGNAL */
 162         }
 163 }
 164
 165 bool
 166 PluginInsert::set_preset_out (const ChanCount& c)
 167 {
 168         bool changed = _preset_out != c;
 169         _preset_out = c;
 170         if (changed && !_custom_cfg) {
 171                 PluginConfigChanged (); /* EMIT SIGNAL */
 172         }
 173         return changed;
 174 }
 175
 176 bool
 177 PluginInsert::add_sidechain (uint32_t n_audio)
 178 {
 179         // caller must hold process lock
 180         if (_sidechain) {
 181                 return false;
 182         }
 183         std::ostringstream n;
 184         if (n_audio > 0) {
 185                 n << "Sidechain " << Session::next_name_id ();
 186         } else {
 187                 n << "TO BE RESET FROM XML";
 188         }
 189         SideChain *sc = new SideChain (_session, n.str ());
 190         _sidechain = boost::shared_ptr<SideChain> (sc);
 191         _sidechain->activate ();
 192         for (uint32_t n = 0; n < n_audio; ++n) {
 193                 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
 194         }
 195         PluginConfigChanged (); /* EMIT SIGNAL */
 196         return true;
 197 }
 198
 199 bool
 200 PluginInsert::del_sidechain ()
 201 {
 202         if (!_sidechain) {
 203                 return false;
 204         }
 205         _sidechain.reset ();
 206         PluginConfigChanged (); /* EMIT SIGNAL */
 207         return true;
 208 }
 209
 210 void
 211 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
 212 {
 213         if (which.type() != PluginAutomation)
 214                 return;
 215
 216         boost::shared_ptr<AutomationControl> c
 217                         = boost::dynamic_pointer_cast<AutomationControl>(control (which));
 218
 219         if (c && s != Off) {
 220                 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
 221         }
 222 }
 223
 224 ChanCount
 225 PluginInsert::output_streams() const
 226 {
 227         assert (_configured);
 228         return _configured_out;
 229 }
 230
 231 ChanCount
 232 PluginInsert::input_streams() const
 233 {
 234         assert (_configured);
 235         return _configured_in;
 236 }
 237
 238 ChanCount
 239 PluginInsert::internal_streams() const
 240 {
 241         assert (_configured);
 242         return _configured_internal;
 243 }
 244
 245 ChanCount
 246 PluginInsert::internal_output_streams() const
 247 {
 248         assert (!_plugins.empty());
 249
 250         PluginInfoPtr info = _plugins.front()->get_info();
 251
 252         if (info->reconfigurable_io()) {
 253                 ChanCount out = _plugins.front()->output_streams ();
 254                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
 255                 return out;
 256         } else {
 257                 ChanCount out = info->n_outputs;
 258                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
 259                 out.set_audio (out.n_audio() * _plugins.size());
 260                 out.set_midi (out.n_midi() * _plugins.size());
 261                 return out;
 262         }
 263 }
 264
 265 ChanCount
 266 PluginInsert::internal_input_streams() const
 267 {
 268         assert (!_plugins.empty());
 269
 270         ChanCount in;
 271
 272         PluginInfoPtr info = _plugins.front()->get_info();
 273
 274         if (info->reconfigurable_io()) {
 275                 in = _plugins.front()->input_streams();
 276         } else {
 277                 in = info->n_inputs;
 278         }
 279
 280         DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
 281
 282         if (_match.method == Split) {
 283
 284                 /* we are splitting 1 processor input to multiple plugin inputs,
 285                    so we have a maximum of 1 stream of each type.
 286                 */
 287                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 288                         if (in.get (*t) > 1) {
 289                                 in.set (*t, 1);
 290                         }
 291                 }
 292                 return in;
 293
 294         } else if (_match.method == Hide) {
 295
 296                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 297                         in.set (*t, in.get (*t) - _match.hide.get (*t));
 298                 }
 299                 return in;
 300
 301         } else {
 302
 303                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 304                         in.set (*t, in.get (*t) * _plugins.size ());
 305                 }
 306
 307                 return in;
 308         }
 309 }
 310
 311 ChanCount
 312 PluginInsert::natural_output_streams() const
 313 {
 314 #ifdef MIXBUS
 315         if (is_channelstrip ()) {
 316                 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
 317         }
 318 #endif
 319         return _plugins[0]->get_info()->n_outputs;
 320 }
 321
 322 ChanCount
 323 PluginInsert::natural_input_streams() const
 324 {
 325 #ifdef MIXBUS
 326         if (is_channelstrip ()) {
 327                 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
 328         }
 329 #endif
 330         return _plugins[0]->get_info()->n_inputs;
 331 }
 332
 333 ChanCount
 334 PluginInsert::sidechain_input_pins() const
 335 {
 336         return _cached_sidechain_pins;
 337 }
 338
 339 bool
 340 PluginInsert::has_no_inputs() const
 341 {
 342         return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
 343 }
 344
 345 bool
 346 PluginInsert::has_no_audio_inputs() const
 347 {
 348         return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
 349 }
 350
 351 framecnt_t
 352 PluginInsert::plugin_latency () const {
 353         return _plugins.front()->signal_latency ();
 354 }
 355
 356 bool
 357 PluginInsert::needs_midi_input() const
 358 {
 359         PluginInfoPtr pip = _plugins[0]->get_info();
 360         if (pip->needs_midi_input ()) {
 361                 return true;
 362         }
 363         return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
 364 }
 365
 366 void
 367 PluginInsert::create_automatable_parameters ()
 368 {
 369         assert (!_plugins.empty());
 370
 371         set<Evoral::Parameter> a = _plugins.front()->automatable ();
 372
 373         for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
 374                 if (i->type() == PluginAutomation) {
 375
 376                         Evoral::Parameter param(*i);
 377
 378                         ParameterDescriptor desc;
 379                         _plugins.front()->get_parameter_descriptor(i->id(), desc);
 380
 381                         can_automate (param);
 382                         boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
 383                         boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
 384                         add_control (c);
 385                         _plugins.front()->set_automation_control (i->id(), c);
 386                 } else if (i->type() == PluginPropertyAutomation) {
 387                         Evoral::Parameter param(*i);
 388                         const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
 389                         if (desc.datatype != Variant::NOTHING) {
 390                                 boost::shared_ptr<AutomationList> list;
 391                                 if (Variant::type_is_numeric(desc.datatype)) {
 392                                         list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
 393                                 }
 394                                 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
 395                         }
 396                 }
 397         }
 398 }
 399 /** Called when something outside of this host has modified a plugin
 400  * parameter. Responsible for propagating the change to two places:
 401  *
 402  *   1) anything listening to the Control itself
 403  *   2) any replicated plugins that make up this PluginInsert.
 404  *
 405  * The PluginInsert is connected to the ParameterChangedExternally signal for
 406  * the first (primary) plugin, and here broadcasts that change to any others.
 407  *
 408  * XXX We should probably drop this whole replication idea (Paul, October 2015)
 409  * since it isn't used by sensible plugin APIs (AU, LV2).
 410  */
 411 void
 412 PluginInsert::parameter_changed_externally (uint32_t which, float val)
 413 {
 414         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
 415
 416         /* First propagation: alter the underlying value of the control,
 417          * without telling the plugin(s) that own/use it to set it.
 418          */
 419
 420         if (!ac) {
 421                 return;
 422         }
 423
 424         boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
 425
 426         if (pc) {
 427                 pc->catch_up_with_external_value (val);
 428         }
 429
 430         /* Second propagation: tell all plugins except the first to
 431            update the value of this parameter. For sane plugin APIs,
 432            there are no other plugins, so this is a no-op in those
 433            cases.
 434         */
 435
 436         Plugins::iterator i = _plugins.begin();
 437
 438         /* don't set the first plugin, just all the slaves */
 439
 440         if (i != _plugins.end()) {
 441                 ++i;
 442                 for (; i != _plugins.end(); ++i) {
 443                         (*i)->set_parameter (which, val);
 444                 }
 445         }
 446 }
 447
 448 int
 449 PluginInsert::set_block_size (pframes_t nframes)
 450 {
 451         int ret = 0;
 452         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 453                 if ((*i)->set_block_size (nframes) != 0) {
 454                         ret = -1;
 455                 }
 456         }
 457         return ret;
 458 }
 459
 460 void
 461 PluginInsert::activate ()
 462 {
 463         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 464                 (*i)->activate ();
 465         }
 466
 467         Processor::activate ();
 468 }
 469
 470 void
 471 PluginInsert::deactivate ()
 472 {
 473         Processor::deactivate ();
 474
 475         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 476                 (*i)->deactivate ();
 477         }
 478 }
 479
 480 void
 481 PluginInsert::flush ()
 482 {
 483         for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 484                 (*i)->flush ();
 485         }
 486 }
 487
 488 void
 489 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
 490 {
 491         // TODO: atomically copy maps & _no_inplace
 492         PinMappings in_map (_in_map);
 493         PinMappings out_map (_out_map);
 494         ChanMapping thru_map (_thru_map);
 495         if (_mapping_changed) { // ToDo use a counters, increment until match.
 496                 _no_inplace = check_inplace ();
 497                 _mapping_changed = false;
 498         }
 499
 500         if (_latency_changed) {
 501                 /* delaylines are configured with the max possible latency (as reported by the plugin)
 502                  * so this won't allocate memory (unless the plugin lied about its max latency)
 503                  * It may still 'click' though, since the fixed delaylines are not de-clicked.
 504                  * Then again plugin-latency changes are not click-free to begin with.
 505                  *
 506                  * This is also worst case, there is currently no concept of per-stream latency.
 507                  *
 508                  * e.g.  Two identical latent plugins:
 509                  *   1st plugin: process left (latent), bypass right.
 510                  *   2nd plugin: bypass left, process right (latent).
 511                  * -> currently this yields 2 times latency of the plugin,
 512                  */
 513                 _latency_changed = false;
 514                 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
 515         }
 516
 517         if (_match.method == Split && !_no_inplace) {
 518                 // TODO: also use this optimization if one source-buffer
 519                 // feeds _all_ *connected* inputs.
 520                 // currently this is *first* buffer to all only --
 521                 // see PluginInsert::check_inplace
 522                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 523                         if (_configured_internal.get (*t) == 0) {
 524                                 continue;
 525                         }
 526                         bool valid;
 527                         uint32_t first_idx = in_map[0].get (*t, 0, &valid);
 528                         assert (valid && first_idx == 0); // check_inplace ensures this
 529                         /* copy the first stream's buffer contents to the others */
 530                         for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
 531                                 uint32_t idx = in_map[0].get (*t, i, &valid);
 532                                 if (valid) {
 533                                         assert (idx == 0);
 534                                         bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
 535                                 }
 536                         }
 537                 }
 538                 /* the copy operation produces a linear monotonic input map */
 539                 in_map[0] = ChanMapping (natural_input_streams ());
 540         }
 541
 542         bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
 543         bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
 544
 545         if (with_auto) {
 546
 547                 uint32_t n = 0;
 548
 549                 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
 550
 551                         boost::shared_ptr<AutomationControl> c
 552                                 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
 553
 554                         if (c->list() && c->automation_playback()) {
 555                                 bool valid;
 556
 557                                 const float val = c->list()->rt_safe_eval (now, valid);
 558
 559                                 if (valid) {
 560                                         /* This is the ONLY place where we are
 561                                          *  allowed to call
 562                                          *  AutomationControl::set_value_unchecked(). We
 563                                          *  know that the control is in
 564                                          *  automation playback mode, so no
 565                                          *  check on writable() is required
 566                                          *  (which must be done in AutomationControl::set_value()
 567                                          *
 568                                          */
 569                                         c->set_value_unchecked(val);
 570                                 }
 571
 572                         }
 573                 }
 574         }
 575
 576         /* Calculate if, and how many frames we need to collect for analysis */
 577         framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
 578                                              _signal_analysis_collected_nframes);
 579         if (nframes < collect_signal_nframes) { // we might not get all frames now
 580                 collect_signal_nframes = nframes;
 581         }
 582
 583         if (collect_signal_nframes > 0) {
 584                 // collect input
 585                 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 586                 //std::cerr << "               streams " << internal_input_streams().n_audio() << std::endl;
 587                 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
 588
 589                 _signal_analysis_inputs.set_count(internal_input_streams());
 590
 591                 for (uint32_t i = 0; i < internal_input_streams().n_audio(); ++i) {
 592                         _signal_analysis_inputs.get_audio(i).read_from(
 593                                 bufs.get_audio(i),
 594                                 collect_signal_nframes,
 595                                 _signal_analysis_collected_nframes); // offset is for target buffer
 596                 }
 597
 598         }
 599 #ifdef MIXBUS
 600         if (is_channelstrip ()) {
 601                 if (_configured_in.n_audio() > 0) {
 602                         ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
 603                         ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
 604
 605                         _plugins.front()->connect_and_run (bufs, mb_in_map, mb_out_map, nframes, offset);
 606
 607                         for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
 608                                 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
 609                         }
 610                 }
 611         } else
 612 #endif
 613         if (_no_inplace) {
 614                 // TODO optimize -- build maps once.
 615                 uint32_t pc = 0;
 616                 BufferSet& inplace_bufs  = _session.get_noinplace_buffers();
 617                 ARDOUR::ChanMapping used_outputs;
 618
 619                 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
 620
 621                 /* build used-output map */
 622                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
 623                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 624                                 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
 625                                         bool valid;
 626                                         uint32_t out_idx = out_map[pc].get (*t, out, &valid);
 627                                         if (valid) {
 628                                                 used_outputs.set (*t, out_idx, 1); // mark as used
 629                                         }
 630                                 }
 631                         }
 632                 }
 633                 /* copy thru data to outputs before processing in-place */
 634                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 635                         for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
 636                                 bool valid;
 637                                 uint32_t in_idx = thru_map.get (*t, out, &valid);
 638                                 if (valid) {
 639                                         uint32_t m = out + natural_input_streams ().get (*t);
 640                                         _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
 641                                         used_outputs.set (*t, out, 1); // mark as used
 642                                 }
 643                         }
 644                 }
 645
 646                 pc = 0;
 647                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
 648
 649                         ARDOUR::ChanMapping i_in_map (natural_input_streams());
 650                         ARDOUR::ChanMapping i_out_map (out_map[pc]);
 651                         ARDOUR::ChanCount mapped;
 652
 653                         /* map inputs sequentially */
 654                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 655                                 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
 656                                         bool valid;
 657                                         uint32_t in_idx = in_map[pc].get (*t, in, &valid);
 658                                         uint32_t m = mapped.get (*t);
 659                                         if (valid) {
 660                                                 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
 661                                         } else {
 662                                                 inplace_bufs.get (*t, m).silence (nframes, offset);
 663                                         }
 664                                         mapped.set (*t, m + 1);
 665                                 }
 666                         }
 667
 668                         /* outputs are mapped to inplace_bufs after the inputs */
 669                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 670                                 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
 671                         }
 672
 673                         if ((*i)->connect_and_run (inplace_bufs, i_in_map, i_out_map, nframes, offset)) {
 674                                 deactivate ();
 675                         }
 676                 }
 677
 678                 /* all instances have completed, now copy data that was written
 679                  * and zero unconnected buffers */
 680                 ARDOUR::ChanMapping nonzero_out (used_outputs);
 681                 if (has_midi_bypass ()) {
 682                         nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
 683                 }
 684                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 685                         for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
 686                                 bool valid;
 687                                 used_outputs.get (*t, out, &valid);
 688                                 if (!valid) {
 689                                         nonzero_out.get (*t, out, &valid);
 690                                         if (!valid) {
 691                                                 bufs.get (*t, out).silence (nframes, offset);
 692                                         }
 693                                 } else {
 694                                         uint32_t m = out + natural_input_streams ().get (*t);
 695                                         bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
 696                                 }
 697                         }
 698                 }
 699         } else {
 700                 /* in-place processing */
 701                 uint32_t pc = 0;
 702                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
 703                         if ((*i)->connect_and_run(bufs, in_map[pc], out_map[pc], nframes, offset)) {
 704                                 deactivate ();
 705                         }
 706                 }
 707
 708                 // TODO optimize: store "unconnected" in a fixed set.
 709                 // it only changes on reconfiguration.
 710                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 711                         for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
 712                                 bool mapped = false;
 713                                 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
 714                                         mapped = true; // in-place Midi bypass
 715                                 }
 716                                 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
 717                                         for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
 718                                                 bool valid;
 719                                                 uint32_t idx = out_map[pc].get (*t, o, &valid);
 720                                                 if (valid && idx == out) {
 721                                                         mapped = true;
 722                                                         break;
 723                                                 }
 724                                         }
 725                                 }
 726                                 if (!mapped) {
 727                                         bufs.get (*t, out).silence (nframes, offset);
 728                                 }
 729                         }
 730                 }
 731         }
 732
 733         if (collect_signal_nframes > 0) {
 734                 // collect output
 735                 //std::cerr << "       output, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 736                 //std::cerr << "               streams " << internal_output_streams().n_audio() << std::endl;
 737
 738                 _signal_analysis_outputs.set_count(internal_output_streams());
 739
 740                 for (uint32_t i = 0; i < internal_output_streams().n_audio(); ++i) {
 741                         _signal_analysis_outputs.get_audio(i).read_from(
 742                                 bufs.get_audio(i),
 743                                 collect_signal_nframes,
 744                                 _signal_analysis_collected_nframes); // offset is for target buffer
 745                 }
 746
 747                 _signal_analysis_collected_nframes += collect_signal_nframes;
 748                 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
 749
 750                 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
 751                         _signal_analysis_collect_nframes_max = 0;
 752                         _signal_analysis_collected_nframes   = 0;
 753
 754                         AnalysisDataGathered(&_signal_analysis_inputs,
 755                                              &_signal_analysis_outputs);
 756                 }
 757         }
 758 }
 759
 760 void
 761 PluginInsert::silence (framecnt_t nframes)
 762 {
 763         if (!active ()) {
 764                 return;
 765         }
 766
 767         _delaybuffers.flush ();
 768
 769         ChanMapping in_map (natural_input_streams ());
 770         ChanMapping out_map (natural_output_streams ());
 771         ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
 772 #ifdef MIXBUS
 773         if (is_channelstrip ()) {
 774                 if (_configured_in.n_audio() > 0) {
 775                         _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0);
 776                 }
 777         } else
 778 #endif
 779         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 780                 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0);
 781         }
 782 }
 783
 784 void
 785 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
 786 {
 787         if (_pending_active) {
 788                 /* run as normal if we are active or moving from inactive to active */
 789
 790                 if (_sidechain) {
 791                         // collect sidechain input for complete cycle (!)
 792                         // TODO we need delaylines here for latency compensation
 793                         _sidechain->run (bufs, start_frame, end_frame, nframes, true);
 794                 }
 795
 796                 if (_session.transport_rolling() || _session.bounce_processing()) {
 797                         automation_run (bufs, start_frame, nframes);
 798                 } else {
 799                         connect_and_run (bufs, nframes, 0, false);
 800                 }
 801
 802         } else {
 803                 // TODO use mapping in bypassed mode ?!
 804                 // -> do we bypass the processor or the plugin
 805
 806                 // TODO include sidechain??
 807
 808                 uint32_t in = input_streams ().n_audio ();
 809                 uint32_t out = output_streams().n_audio ();
 810
 811                 if (has_no_audio_inputs() || in == 0) {
 812
 813                         /* silence all (audio) outputs. Should really declick
 814                          * at the transitions of "active"
 815                          */
 816
 817                         for (uint32_t n = 0; n < out; ++n) {
 818                                 bufs.get_audio (n).silence (nframes);
 819                         }
 820
 821                 } else if (out > in) {
 822
 823                         /* not active, but something has make up for any channel count increase
 824                          * for now , simply replicate last buffer
 825                          */
 826                         for (uint32_t n = in; n < out; ++n) {
 827                                 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
 828                         }
 829                 }
 830
 831                 bufs.count().set_audio (out);
 832         }
 833
 834         _active = _pending_active;
 835
 836         /* we have no idea whether the plugin generated silence or not, so mark
 837          * all buffers appropriately.
 838          */
 839 }
 840
 841 void
 842 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
 843 {
 844         Evoral::ControlEvent next_event (0, 0.0f);
 845         framepos_t now = start;
 846         framepos_t end = now + nframes;
 847         framecnt_t offset = 0;
 848
 849         Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
 850
 851         if (!lm.locked()) {
 852                 connect_and_run (bufs, nframes, offset, false);
 853                 return;
 854         }
 855
 856         if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
 857
 858                 /* no events have a time within the relevant range */
 859
 860                 connect_and_run (bufs, nframes, offset, true, now);
 861                 return;
 862         }
 863
 864         while (nframes) {
 865
 866                 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
 867
 868                 connect_and_run (bufs, cnt, offset, true, now);
 869
 870                 nframes -= cnt;
 871                 offset += cnt;
 872                 now += cnt;
 873
 874                 if (!find_next_event (now, end, next_event)) {
 875                         break;
 876                 }
 877         }
 878
 879         /* cleanup anything that is left to do */
 880
 881         if (nframes) {
 882                 connect_and_run (bufs, nframes, offset, true, now);
 883         }
 884 }
 885
 886 float
 887 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
 888 {
 889         if (param.type() != PluginAutomation)
 890                 return 1.0;
 891
 892         if (_plugins.empty()) {
 893                 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
 894                       << endmsg;
 895                 abort(); /*NOTREACHED*/
 896         }
 897
 898         return _plugins[0]->default_value (param.id());
 899 }
 900
 901
 902 bool
 903 PluginInsert::can_reset_all_parameters ()
 904 {
 905         bool all = true;
 906         uint32_t params = 0;
 907         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 908                 bool ok=false;
 909                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 910
 911                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 912                         continue;
 913                 }
 914
 915                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 916                 if (!ac) {
 917                         continue;
 918                 }
 919
 920                 ++params;
 921                 if (ac->automation_state() & Play) {
 922                         all = false;
 923                         break;
 924                 }
 925         }
 926         return all && (params > 0);
 927 }
 928
 929 bool
 930 PluginInsert::reset_parameters_to_default ()
 931 {
 932         bool all = true;
 933
 934         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 935                 bool ok=false;
 936                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 937
 938                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 939                         continue;
 940                 }
 941
 942                 const float dflt = _plugins[0]->default_value (cid);
 943                 const float curr = _plugins[0]->get_parameter (cid);
 944
 945                 if (dflt == curr) {
 946                         continue;
 947                 }
 948
 949                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 950                 if (!ac) {
 951                         continue;
 952                 }
 953
 954                 if (ac->automation_state() & Play) {
 955                         all = false;
 956                         continue;
 957                 }
 958
 959                 ac->set_value (dflt, Controllable::NoGroup);
 960         }
 961         return all;
 962 }
 963
 964 boost::shared_ptr<Plugin>
 965 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
 966 {
 967         boost::shared_ptr<LadspaPlugin> lp;
 968         boost::shared_ptr<LuaProc> lua;
 969 #ifdef LV2_SUPPORT
 970         boost::shared_ptr<LV2Plugin> lv2p;
 971 #endif
 972 #ifdef WINDOWS_VST_SUPPORT
 973         boost::shared_ptr<WindowsVSTPlugin> vp;
 974 #endif
 975 #ifdef LXVST_SUPPORT
 976         boost::shared_ptr<LXVSTPlugin> lxvp;
 977 #endif
 978 #ifdef AUDIOUNIT_SUPPORT
 979         boost::shared_ptr<AUPlugin> ap;
 980 #endif
 981
 982         if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
 983                 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
 984         } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
 985                 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
 986 #ifdef LV2_SUPPORT
 987         } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
 988                 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
 989 #endif
 990 #ifdef WINDOWS_VST_SUPPORT
 991         } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
 992                 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
 993 #endif
 994 #ifdef LXVST_SUPPORT
 995         } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
 996                 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
 997 #endif
 998 #ifdef AUDIOUNIT_SUPPORT
 999         } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1000                 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1001 #endif
1002         }
1003
1004         fatal << string_compose (_("programming error: %1"),
1005                           X_("unknown plugin type in PluginInsert::plugin_factory"))
1006               << endmsg;
1007         abort(); /*NOTREACHED*/
1008         return boost::shared_ptr<Plugin> ((Plugin*) 0);
1009 }
1010
1011 void
1012 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1013         if (num < _in_map.size()) {
1014                 bool changed = _in_map[num] != m;
1015                 _in_map[num] = m;
1016                 changed |= sanitize_maps ();
1017                 if (changed) {
1018                         PluginMapChanged (); /* EMIT SIGNAL */
1019                         _mapping_changed = true;
1020                         _session.set_dirty();
1021                 }
1022         }
1023 }
1024
1025 void
1026 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1027         if (num < _out_map.size()) {
1028                 bool changed = _out_map[num] != m;
1029                 _out_map[num] = m;
1030                 changed |= sanitize_maps ();
1031                 if (changed) {
1032                         PluginMapChanged (); /* EMIT SIGNAL */
1033                         _mapping_changed = true;
1034                         _session.set_dirty();
1035                 }
1036         }
1037 }
1038
1039 void
1040 PluginInsert::set_thru_map (ChanMapping m) {
1041         bool changed = _thru_map != m;
1042         _thru_map = m;
1043         changed |= sanitize_maps ();
1044         if (changed) {
1045                 PluginMapChanged (); /* EMIT SIGNAL */
1046                 _mapping_changed = true;
1047                 _session.set_dirty();
1048         }
1049 }
1050
1051 ChanMapping
1052 PluginInsert::input_map () const
1053 {
1054         ChanMapping rv;
1055         uint32_t pc = 0;
1056         for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1057                 ChanMapping m (i->second);
1058                 const ChanMapping::Mappings& mp ((*i).second.mappings());
1059                 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1060                         for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1061                                 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1062                         }
1063                 }
1064         }
1065         return rv;
1066 }
1067
1068 ChanMapping
1069 PluginInsert::output_map () const
1070 {
1071         ChanMapping rv;
1072         uint32_t pc = 0;
1073         for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1074                 ChanMapping m (i->second);
1075                 const ChanMapping::Mappings& mp ((*i).second.mappings());
1076                 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1077                         for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1078                                 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1079                         }
1080                 }
1081         }
1082         if (has_midi_bypass ()) {
1083                 rv.set (DataType::MIDI, 0, 0);
1084         }
1085
1086         return rv;
1087 }
1088
1089 bool
1090 PluginInsert::has_midi_bypass () const
1091 {
1092         if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1093                         && natural_output_streams ().n_midi () == 0) {
1094                 return true;
1095         }
1096         return false;
1097 }
1098
1099 bool
1100 PluginInsert::has_midi_thru () const
1101 {
1102         if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1103                         && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1104                 return true;
1105         }
1106         return false;
1107 }
1108
1109 #ifdef MIXBUS
1110 bool
1111 PluginInsert::is_channelstrip () const {
1112         return _plugins.front()->is_channelstrip();
1113 }
1114 #endif
1115
1116 bool
1117 PluginInsert::check_inplace ()
1118 {
1119         bool inplace_ok = !_plugins.front()->inplace_broken ();
1120
1121         if (_thru_map.n_total () > 0) {
1122                 // TODO once midi-bypass is part of the mapping, ignore it
1123                 inplace_ok = false;
1124         }
1125
1126         if (_match.method == Split && inplace_ok) {
1127                 assert (get_count() == 1);
1128                 assert (_in_map.size () == 1);
1129                 if (!_out_map[0].is_monotonic ()) {
1130                         inplace_ok = false;
1131                 }
1132                 if (_configured_internal != _configured_in) {
1133                         /* no sidechain -- TODO we could allow this with
1134                          * some more logic in PluginInsert::connect_and_run().
1135                          *
1136                          * PluginInsert::reset_map() already maps it.
1137                          */
1138                         inplace_ok = false;
1139                 }
1140                 /* check mapping */
1141                 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1142                         if (_configured_internal.get (*t) == 0) {
1143                                 continue;
1144                         }
1145                         bool valid;
1146                         uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1147                         if (!valid || first_idx != 0) {
1148                                 // so far only allow to copy the *first* stream's buffer to others
1149                                 inplace_ok = false;
1150                         } else {
1151                                 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1152                                         uint32_t idx = _in_map[0].get (*t, i, &valid);
1153                                         if (valid && idx != first_idx) {
1154                                                 inplace_ok = false;
1155                                                 break;
1156                                         }
1157                                 }
1158                         }
1159                 }
1160
1161                 if (inplace_ok) {
1162                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1163                         return false;
1164                 }
1165         }
1166
1167         for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1168                 if (!_in_map[pc].is_monotonic ()) {
1169                         inplace_ok = false;
1170                 }
1171                 if (!_out_map[pc].is_monotonic ()) {
1172                         inplace_ok = false;
1173                 }
1174         }
1175         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1176         return !inplace_ok; // no-inplace
1177 }
1178
1179 bool
1180 PluginInsert::sanitize_maps ()
1181 {
1182         bool changed = false;
1183         /* strip dead wood */
1184         PinMappings new_ins;
1185         PinMappings new_outs;
1186         ChanMapping new_thru;
1187
1188         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1189                 ChanMapping new_in;
1190                 ChanMapping new_out;
1191                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1192                         for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1193                                 bool valid;
1194                                 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1195                                 if (valid && idx < _configured_internal.get (*t)) {
1196                                         new_in.set (*t, i, idx);
1197                                 }
1198                         }
1199                         for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1200                                 bool valid;
1201                                 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1202                                 if (valid && idx < _configured_out.get (*t)) {
1203                                         new_out.set (*t, o, idx);
1204                                 }
1205                         }
1206                 }
1207                 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1208                         changed = true;
1209                 }
1210                 new_ins[pc] = new_in;
1211                 new_outs[pc] = new_out;
1212         }
1213
1214         /* prevent dup output assignments */
1215         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1216                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1217                         bool mapped = false;
1218                         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1219                                 bool valid;
1220                                 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1221                                 if (valid && mapped) {
1222                                         new_outs[pc].unset (*t, idx);
1223                                 } else if (valid) {
1224                                         mapped = true;
1225                                 }
1226                         }
1227                 }
1228         }
1229
1230         /* remove excess thru */
1231         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1232                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1233                         bool valid;
1234                         uint32_t idx = _thru_map.get (*t, o, &valid);
1235                         if (valid && idx < _configured_internal.get (*t)) {
1236                                 new_thru.set (*t, o, idx);
1237                         }
1238                 }
1239         }
1240
1241         /* prevent out + thru,  existing plugin outputs override thru */
1242         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1243                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1244                         bool mapped = false;
1245                         bool valid;
1246                         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1247                                 new_outs[pc].get_src (*t, o, &mapped);
1248                                 if (mapped) { break; }
1249                         }
1250                         if (!mapped) { continue; }
1251                         uint32_t idx = new_thru.get (*t, o, &valid);
1252                         if (mapped) {
1253                                 new_thru.unset (*t, idx);
1254                         }
1255                 }
1256         }
1257
1258         if (has_midi_bypass ()) {
1259                 // TODO: include midi-bypass in the thru set,
1260                 // remove dedicated handling.
1261                 new_thru.unset (DataType::MIDI, 0);
1262         }
1263
1264         if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1265                 changed = true;
1266         }
1267         _in_map = new_ins;
1268         _out_map = new_outs;
1269         _thru_map = new_thru;
1270
1271         return changed;
1272 }
1273
1274 bool
1275 PluginInsert::reset_map (bool emit)
1276 {
1277         const PinMappings old_in (_in_map);
1278         const PinMappings old_out (_out_map);
1279
1280         _in_map.clear ();
1281         _out_map.clear ();
1282         _thru_map = ChanMapping ();
1283
1284         /* build input map */
1285         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1286                 uint32_t sc = 0; // side-chain round-robin (all instances)
1287                 uint32_t pc = 0;
1288                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1289                         const uint32_t nis = natural_input_streams ().get(*t);
1290                         const uint32_t stride = nis - sidechain_input_pins().get (*t);
1291
1292                         /* SC inputs are last in the plugin-insert.. */
1293                         const uint32_t sc_start = _configured_in.get (*t);
1294                         const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1295                         /* ...but may not be at the end of the plugin ports.
1296                          * in case the side-chain is not the last port, shift connections back.
1297                          * and connect to side-chain
1298                          */
1299                         uint32_t shift = 0;
1300                         uint32_t ic = 0; // split inputs
1301                         const uint32_t cend = _configured_in.get (*t);
1302
1303                         for (uint32_t in = 0; in < nis; ++in) {
1304                                 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1305                                 if (iod.is_sidechain) {
1306                                         /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1307                                         if (sc_len > 0) {// side-chain may be hidden
1308                                                 _in_map[pc].set (*t, in, sc_start + sc);
1309                                                 sc = (sc + 1) % sc_len;
1310                                         }
1311                                         ++shift;
1312                                 } else {
1313                                         if (_match.method == Split) {
1314                                                 if (cend == 0) { continue; }
1315                                                 if (_strict_io && ic + stride * pc >= cend) {
1316                                                         break;
1317                                                 }
1318                                                 /* connect *no* sidechain sinks in round-robin fashion */
1319                                                 _in_map[pc].set (*t, in, ic + stride * pc);
1320                                                 if (_strict_io && (ic + 1) == cend) {
1321                                                         break;
1322                                                 }
1323                                                 ic = (ic + 1) % cend;
1324                                         } else {
1325                                                 uint32_t s = in - shift;
1326                                                 if (stride * pc + s < cend) {
1327                                                         _in_map[pc].set (*t, in, s + stride * pc);
1328                                                 }
1329                                         }
1330                                 }
1331                         }
1332                 }
1333         }
1334
1335         /* build output map */
1336         uint32_t pc = 0;
1337         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1338                 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1339                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1340                         _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1341                 }
1342         }
1343
1344         sanitize_maps ();
1345         if (old_in == _in_map && old_out == _out_map) {
1346                 return false;
1347         }
1348         if (emit) {
1349                 PluginMapChanged (); /* EMIT SIGNAL */
1350                 _mapping_changed = true;
1351                 _session.set_dirty();
1352         }
1353         return true;
1354 }
1355
1356 bool
1357 PluginInsert::configure_io (ChanCount in, ChanCount out)
1358 {
1359         Match old_match = _match;
1360         ChanCount old_in;
1361         ChanCount old_internal;
1362         ChanCount old_out;
1363
1364         if (_configured) {
1365                 old_in = _configured_in;
1366                 old_internal = _configured_internal;
1367                 old_out = _configured_out;
1368         }
1369
1370         _configured_in = in;
1371         _configured_internal = in;
1372         _configured_out = out;
1373
1374         if (_sidechain) {
1375                 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1376                  * (currently _sidechain->configure_io always succeeds
1377                  *  since Processor::configure_io() succeeds)
1378                  */
1379                 if (!_sidechain->configure_io (in, out)) {
1380                         DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1381                         return false;
1382                 }
1383                 _configured_internal += _sidechain->input()->n_ports();
1384
1385                 // include (static_cast<Route*>owner())->name() ??
1386                 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1387         }
1388
1389         /* get plugin configuration */
1390         _match = private_can_support_io_configuration (in, out);
1391 #ifndef NDEBUG
1392         if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1393                 DEBUG_STR_DECL(a);
1394                 DEBUG_STR_APPEND(a, string_compose ("Match '%1': ",  name()));
1395                 DEBUG_STR_APPEND(a, _match);
1396                 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1397         }
1398 #endif
1399
1400         /* set the matching method and number of plugins that we will use to meet this configuration */
1401         if (set_count (_match.plugins) == false) {
1402                 PluginIoReConfigure (); /* EMIT SIGNAL */
1403                 _configured = false;
1404                 return false;
1405         }
1406
1407         /* configure plugins */
1408         switch (_match.method) {
1409         case Split:
1410         case Hide:
1411                 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1412                         PluginIoReConfigure (); /* EMIT SIGNAL */
1413                         _configured = false;
1414                         return false;
1415                 }
1416                 break;
1417         case Delegate:
1418                 {
1419                         ChanCount dout (in); // hint
1420                         if (_custom_cfg) {
1421                                 dout = _custom_out;
1422                         } else if (_preset_out.n_audio () > 0) {
1423                                 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1424                         } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1425                                 dout.set (DataType::AUDIO, 2);
1426                         }
1427                         if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1428                         ChanCount useins;
1429                         bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1430                         assert (r);
1431                         if (useins.n_audio() == 0) {
1432                                 useins = in;
1433                         }
1434                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("Delegate configuration: %1 %2 %3\n", name(), useins, dout));
1435
1436                         if (_plugins.front()->configure_io (useins, dout) == false) {
1437                                 PluginIoReConfigure (); /* EMIT SIGNAL */
1438                                 _configured = false;
1439                                 return false;
1440                         }
1441                 }
1442                 break;
1443         default:
1444                 if (_plugins.front()->configure_io (in, out) == false) {
1445                         PluginIoReConfigure (); /* EMIT SIGNAL */
1446                         _configured = false;
1447                         return false;
1448                 }
1449                 break;
1450         }
1451
1452         bool mapping_changed = false;
1453         if (old_in == in && old_out == out
1454                         && _configured
1455                         && old_match.method == _match.method
1456                         && _in_map.size() == _out_map.size()
1457                         && _in_map.size() == get_count ()
1458                  ) {
1459                 assert (_maps_from_state == false);
1460                 /* If the configuration has not changed, keep the mapping */
1461                 if (old_internal != _configured_internal) {
1462                         mapping_changed = sanitize_maps ();
1463                 }
1464         } else if (_match.custom_cfg && _configured) {
1465                 assert (_maps_from_state == false);
1466                 mapping_changed = sanitize_maps ();
1467         } else {
1468 #ifdef MIXBUS
1469                 if (is_channelstrip ()) {
1470                         /* fake channel map - for wire display */
1471                         _maps_from_state = false;
1472                         _in_map.clear ();
1473                         _out_map.clear ();
1474                         _thru_map = ChanMapping ();
1475                         _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1476                         _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1477                         /* set "thru" map for in-place forward of audio */
1478                         for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1479                                 _thru_map.set (DataType::AUDIO, i, i);
1480                         }
1481                         /* and midi (after implicit 1st channel bypass) */
1482                         for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1483                                 _thru_map.set (DataType::MIDI, i, i);
1484                         }
1485                 } else
1486 #endif
1487                 if (_maps_from_state) {
1488                         _maps_from_state = false;
1489                         mapping_changed = true;
1490                         sanitize_maps ();
1491                 } else {
1492                         /* generate a new mapping */
1493                         mapping_changed = reset_map (false);
1494                 }
1495         }
1496
1497         if (mapping_changed) {
1498                 PluginMapChanged (); /* EMIT SIGNAL */
1499
1500 #ifndef NDEBUG
1501                 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1502                         uint32_t pc = 0;
1503                         DEBUG_STR_DECL(a);
1504                         DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1505                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1506                                 if (pc > 0) {
1507                         DEBUG_STR_APPEND(a, "----><----\n");
1508                                 }
1509                                 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1510                                 DEBUG_STR_APPEND(a, " * Inputs:\n");
1511                                 DEBUG_STR_APPEND(a, _in_map[pc]);
1512                                 DEBUG_STR_APPEND(a, " * Outputs:\n");
1513                                 DEBUG_STR_APPEND(a, _out_map[pc]);
1514                         }
1515                         DEBUG_STR_APPEND(a, " * Thru:\n");
1516                         DEBUG_STR_APPEND(a, _thru_map);
1517                         DEBUG_STR_APPEND(a, "-------->>--------\n");
1518                         DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1519                 }
1520 #endif
1521         }
1522
1523         _no_inplace = check_inplace ();
1524         _mapping_changed = false;
1525
1526         /* only the "noinplace_buffers" thread buffers need to be this large,
1527          * this can be optimized. other buffers are fine with
1528          * ChanCount::max (natural_input_streams (), natural_output_streams())
1529          * and route.cc's max (configured_in, configured_out)
1530          *
1531          * no-inplace copies "thru" outputs (to emulate in-place) for
1532          * all outputs (to prevent overwrite) into a temporary space
1533          * which also holds input buffers (in case the plugin does process
1534          * in-place and overwrites those).
1535          *
1536          * this buffers need to be at least as
1537          *   natural_input_streams () + possible outputs.
1538          *
1539          * sidechain inputs add a constraint on the input:
1540          * configured input + sidechain (=_configured_internal)
1541          *
1542          * NB. this also satisfies
1543          * max (natural_input_streams(), natural_output_streams())
1544          * which is needed for silence runs
1545          */
1546         _required_buffers = ChanCount::max (_configured_internal,
1547                         natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1548
1549         if (old_in != in || old_out != out || old_internal != _configured_internal
1550                         || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1551                  ) {
1552                 PluginIoReConfigure (); /* EMIT SIGNAL */
1553         }
1554
1555         _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1556         _latency_changed = true;
1557
1558         // we don't know the analysis window size, so we must work with the
1559         // current buffer size here. each request for data fills in these
1560         // buffers and the analyser makes sure it gets enough data for the
1561         // analysis window
1562         session().ensure_buffer_set (_signal_analysis_inputs, in);
1563         //_signal_analysis_inputs.set_count (in);
1564
1565         session().ensure_buffer_set (_signal_analysis_outputs, out);
1566         //_signal_analysis_outputs.set_count (out);
1567
1568         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1569
1570         _configured = true;
1571         return Processor::configure_io (in, out);
1572 }
1573
1574 /** Decide whether this PluginInsert can support a given IO configuration.
1575  *  To do this, we run through a set of possible solutions in rough order of
1576  *  preference.
1577  *
1578  *  @param in Required input channel count.
1579  *  @param out Filled in with the output channel count if we return true.
1580  *  @return true if the given IO configuration can be supported.
1581  */
1582 bool
1583 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1584 {
1585         if (_sidechain) {
1586                 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1587         }
1588         return private_can_support_io_configuration (in, out).method != Impossible;
1589 }
1590
1591 PluginInsert::Match
1592 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1593 {
1594         if (!_custom_cfg && _preset_out.n_audio () > 0) {
1595                 // preseed hint (for variable i/o)
1596                 out.set (DataType::AUDIO, _preset_out.n_audio ());
1597         }
1598
1599         Match rv = internal_can_support_io_configuration (in, out);
1600
1601         if (!_custom_cfg && _preset_out.n_audio () > 0) {
1602                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("using output preset: %1 %2\n", name(), _preset_out));
1603                 out.set (DataType::AUDIO, _preset_out.n_audio ());
1604         }
1605         return rv;
1606 }
1607
1608 /** A private version of can_support_io_configuration which returns the method
1609  *  by which the configuration can be matched, rather than just whether or not
1610  *  it can be.
1611  */
1612 PluginInsert::Match
1613 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1614 {
1615         if (_plugins.empty()) {
1616                 return Match();
1617         }
1618
1619 #ifdef MIXBUS
1620         if (is_channelstrip ()) {
1621                 out = inx;
1622                 return Match (ExactMatch, 1);
1623         }
1624 #endif
1625
1626         /* if a user specified a custom cfg, so be it. */
1627         if (_custom_cfg) {
1628                 PluginInfoPtr info = _plugins.front()->get_info();
1629                 out = _custom_out;
1630                 if (info->reconfigurable_io()) {
1631                         return Match (Delegate, get_count(), _strict_io, true);
1632                 } else {
1633                         return Match (ExactMatch, get_count(), _strict_io, true);
1634                 }
1635         }
1636
1637         /* try automatic configuration */
1638         Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1639
1640         PluginInfoPtr info = _plugins.front()->get_info();
1641         ChanCount inputs  = info->n_inputs;
1642         ChanCount outputs = info->n_outputs;
1643
1644         /* handle case strict-i/o */
1645         if (_strict_io && m.method != Impossible) {
1646                 m.strict_io = true;
1647
1648                 /* special case MIDI instruments */
1649                 if (needs_midi_input ()) {
1650                         // output = midi-bypass + at most master-out channels.
1651                         ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1652                         max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1653                         out = ChanCount::min (out, max_out);
1654                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o instrument: %1\n", name()));
1655                         return m;
1656                 }
1657
1658                 switch (m.method) {
1659                         case NoInputs:
1660                                 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1661                                         /* replicate processor to match output count (generators and such)
1662                                          * at least enough to feed every output port. */
1663                                         uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1664                                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1665                                                 uint32_t nout = outputs.get (*t);
1666                                                 if (nout == 0 || inx.get(*t) == 0) { continue; }
1667                                                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1668                                         }
1669                                         out = inx;
1670                                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o generator: %1\n", name()));
1671                                         return Match (Replicate, f, _strict_io);
1672                                 }
1673                                 break;
1674                         default:
1675                                 break;
1676                 }
1677
1678                 out = inx;
1679                 return m;
1680         }
1681
1682         if (m.method != Impossible) {
1683                 return m;
1684         }
1685
1686         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1687
1688         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
1689
1690         if (info->reconfigurable_io()) {
1691                 ChanCount useins;
1692                 out = inx; // hint
1693                 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1694                 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1695                 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1696                 if (!r) {
1697                         // houston, we have a problem.
1698                         return Match (Impossible, 0);
1699                 }
1700                 return Match (Delegate, 1, _strict_io);
1701         }
1702
1703         ChanCount midi_bypass;
1704         if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1705                 midi_bypass.set (DataType::MIDI, 1);
1706         }
1707
1708         // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1709         uint32_t f = 0;
1710         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1711                 uint32_t nin = ns_inputs.get (*t);
1712                 uint32_t nout = outputs.get (*t);
1713                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1714                 // prefer floor() so the count won't overly increase IFF (nin < nout)
1715                 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1716         }
1717         if (f > 0 && outputs * f >= _configured_out) {
1718                 out = outputs * f + midi_bypass;
1719                 return Match (Replicate, f, _strict_io);
1720         }
1721
1722         // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1723         f = 0;
1724         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1725                 uint32_t nin = ns_inputs.get (*t);
1726                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1727                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1728         }
1729         if (f > 0) {
1730                 out = outputs * f + midi_bypass;
1731                 return Match (Replicate, f, _strict_io);
1732         }
1733
1734         // add at least as many plugins needed to connect all inputs
1735         f = 1;
1736         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1737                 uint32_t nin = inputs.get (*t);
1738                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1739                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1740         }
1741         out = outputs * f + midi_bypass;
1742         return Match (Replicate, f, _strict_io);
1743 }
1744
1745 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1746 PluginInsert::Match
1747 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1748 {
1749         if (_plugins.empty()) {
1750                 return Match();
1751         }
1752
1753         PluginInfoPtr info = _plugins.front()->get_info();
1754         ChanCount in; in += inx;
1755         ChanCount midi_bypass;
1756
1757         if (info->reconfigurable_io()) {
1758                 /* Plugin has flexible I/O, so delegate to it
1759                  * pre-seed outputs, plugin tries closest match
1760                  */
1761                 out = in; // hint
1762                 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1763                 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1764                 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1765                 if (!r) {
1766                         return Match (Impossible, 0);
1767                 }
1768                 return Match (Delegate, 1);
1769         }
1770
1771         ChanCount inputs  = info->n_inputs;
1772         ChanCount outputs = info->n_outputs;
1773         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1774
1775         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1776                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1777                 midi_bypass.set (DataType::MIDI, 1);
1778         }
1779         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1780                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1781                 in.set(DataType::MIDI, 0);
1782         }
1783
1784         // add internally provided sidechain ports
1785         ChanCount insc = in + sidechain_input_ports ();
1786
1787         bool no_inputs = true;
1788         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1789                 if (inputs.get (*t) != 0) {
1790                         no_inputs = false;
1791                         break;
1792                 }
1793         }
1794
1795         if (no_inputs) {
1796                 /* no inputs so we can take any input configuration since we throw it away */
1797                 out = outputs + midi_bypass;
1798                 return Match (NoInputs, 1);
1799         }
1800
1801         /* Plugin inputs match requested inputs + side-chain-ports exactly */
1802         if (inputs == insc) {
1803                 out = outputs + midi_bypass;
1804                 return Match (ExactMatch, 1);
1805         }
1806
1807         /* Plugin inputs matches without side-chain-pins */
1808         if (ns_inputs == in) {
1809                 out = outputs + midi_bypass;
1810                 return Match (ExactMatch, 1);
1811         }
1812
1813         /* We may be able to run more than one copy of the plugin within this insert
1814            to cope with the insert having more inputs than the plugin.
1815            We allow replication only for plugins with either zero or 1 inputs and outputs
1816            for every valid data type.
1817         */
1818
1819         uint32_t f             = 0;
1820         bool     can_replicate = true;
1821         for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
1822
1823                 // ignore side-chains
1824                 uint32_t nin = ns_inputs.get (*t);
1825
1826                 // No inputs of this type
1827                 if (nin == 0 && in.get(*t) == 0) {
1828                         continue;
1829                 }
1830
1831                 if (nin != 1 || outputs.get (*t) != 1) {
1832                         can_replicate = false;
1833                         break;
1834                 }
1835
1836                 // Potential factor not set yet
1837                 if (f == 0) {
1838                         f = in.get(*t) / nin;
1839                 }
1840
1841                 // Factor for this type does not match another type, can not replicate
1842                 if (f != (in.get(*t) / nin)) {
1843                         can_replicate = false;
1844                         break;
1845                 }
1846         }
1847
1848         if (can_replicate && f > 0) {
1849                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1850                         out.set (*t, outputs.get(*t) * f);
1851                 }
1852                 out += midi_bypass;
1853                 return Match (Replicate, f);
1854         }
1855
1856         /* If the processor has exactly one input of a given type, and
1857            the plugin has more, we can feed the single processor input
1858            to some or all of the plugin inputs.  This is rather
1859            special-case-y, but the 1-to-many case is by far the
1860            simplest.  How do I split thy 2 processor inputs to 3
1861            plugin inputs?  Let me count the ways ...
1862         */
1863
1864         bool can_split = true;
1865         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1866
1867                 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
1868                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1869
1870                 if (!can_split_type && !nothing_to_do_for_type) {
1871                         can_split = false;
1872                 }
1873         }
1874
1875         if (can_split) {
1876                 out = outputs + midi_bypass;
1877                 return Match (Split, 1);
1878         }
1879
1880         /* If the plugin has more inputs than we want, we can `hide' some of them
1881            by feeding them silence.
1882         */
1883
1884         bool could_hide = false;
1885         bool cannot_hide = false;
1886         ChanCount hide_channels;
1887
1888         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1889                 if (inputs.get(*t) > in.get(*t)) {
1890                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1891                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1892                         could_hide = true;
1893                 } else if (inputs.get(*t) < in.get(*t)) {
1894                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1895                         cannot_hide = true;
1896                 }
1897         }
1898
1899         if (could_hide && !cannot_hide) {
1900                 out = outputs + midi_bypass;
1901                 return Match (Hide, 1, false, false, hide_channels);
1902         }
1903
1904         return Match (Impossible, 0);
1905 }
1906
1907
1908 XMLNode&
1909 PluginInsert::get_state ()
1910 {
1911         return state (true);
1912 }
1913
1914 XMLNode&
1915 PluginInsert::state (bool full)
1916 {
1917         XMLNode& node = Processor::state (full);
1918
1919         node.add_property("type", _plugins[0]->state_node_name());
1920         node.add_property("unique-id", _plugins[0]->unique_id());
1921         node.add_property("count", string_compose("%1", _plugins.size()));
1922
1923         /* remember actual i/o configuration (for later placeholder
1924          * in case the plugin goes missing) */
1925         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1926         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1927         node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
1928
1929         /* save custom i/o config */
1930         node.add_property("custom", _custom_cfg ? "yes" : "no");
1931         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1932                 char tmp[128];
1933                 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1934                 node.add_child_nocopy (* _in_map[pc].state (tmp));
1935                 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1936                 node.add_child_nocopy (* _out_map[pc].state (tmp));
1937         }
1938         node.add_child_nocopy (* _thru_map.state ("ThruMap"));
1939
1940         if (_sidechain) {
1941                 node.add_child_nocopy (_sidechain->state (full));
1942         }
1943
1944         _plugins[0]->set_insert_id(this->id());
1945         node.add_child_nocopy (_plugins[0]->get_state());
1946
1947         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1948                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1949                 if (ac) {
1950                         node.add_child_nocopy (ac->get_state());
1951                 }
1952         }
1953
1954         return node;
1955 }
1956
1957 void
1958 PluginInsert::set_control_ids (const XMLNode& node, int version)
1959 {
1960         const XMLNodeList& nlist = node.children();
1961         XMLNodeConstIterator iter;
1962         set<Evoral::Parameter>::const_iterator p;
1963
1964         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1965                 if ((*iter)->name() == Controllable::xml_node_name) {
1966                         const XMLProperty* prop;
1967
1968                         uint32_t p = (uint32_t)-1;
1969 #ifdef LV2_SUPPORT
1970                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1971                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1972                                 if (lv2plugin) {
1973                                         p = lv2plugin->port_index(prop->value().c_str());
1974                                 }
1975                         }
1976 #endif
1977                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1978                                 p = atoi (prop->value());
1979                         }
1980
1981                         if (p != (uint32_t)-1) {
1982
1983                                 /* this may create the new controllable */
1984
1985                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1986
1987 #ifndef NO_PLUGIN_STATE
1988                                 if (!c) {
1989                                         continue;
1990                                 }
1991                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1992                                 if (ac) {
1993                                         ac->set_state (**iter, version);
1994                                 }
1995 #endif
1996                         }
1997                 }
1998         }
1999 }
2000
2001 int
2002 PluginInsert::set_state(const XMLNode& node, int version)
2003 {
2004         XMLNodeList nlist = node.children();
2005         XMLNodeIterator niter;
2006         XMLPropertyList plist;
2007         const XMLProperty *prop;
2008         ARDOUR::PluginType type;
2009
2010         if ((prop = node.property ("type")) == 0) {
2011                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2012                 return -1;
2013         }
2014
2015         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2016                 type = ARDOUR::LADSPA;
2017         } else if (prop->value() == X_("lv2")) {
2018                 type = ARDOUR::LV2;
2019         } else if (prop->value() == X_("windows-vst")) {
2020                 type = ARDOUR::Windows_VST;
2021         } else if (prop->value() == X_("lxvst")) {
2022                 type = ARDOUR::LXVST;
2023         } else if (prop->value() == X_("audiounit")) {
2024                 type = ARDOUR::AudioUnit;
2025         } else if (prop->value() == X_("luaproc")) {
2026                 type = ARDOUR::Lua;
2027         } else {
2028                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2029                                   prop->value())
2030                       << endmsg;
2031                 return -1;
2032         }
2033
2034         prop = node.property ("unique-id");
2035
2036         if (prop == 0) {
2037 #ifdef WINDOWS_VST_SUPPORT
2038                 /* older sessions contain VST plugins with only an "id" field.
2039                  */
2040
2041                 if (type == ARDOUR::Windows_VST) {
2042                         prop = node.property ("id");
2043                 }
2044 #endif
2045
2046 #ifdef LXVST_SUPPORT
2047                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2048
2049                 if (type == ARDOUR::LXVST) {
2050                         prop = node.property ("id");
2051                 }
2052 #endif
2053                 /* recheck  */
2054
2055                 if (prop == 0) {
2056                         error << _("Plugin has no unique ID field") << endmsg;
2057                         return -1;
2058                 }
2059         }
2060
2061         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2062
2063         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2064          * allow to move sessions windows <> linux */
2065 #ifdef LXVST_SUPPORT
2066         if (plugin == 0 && type == ARDOUR::Windows_VST) {
2067                 type = ARDOUR::LXVST;
2068                 plugin = find_plugin (_session, prop->value(), type);
2069         }
2070 #endif
2071
2072 #ifdef WINDOWS_VST_SUPPORT
2073         if (plugin == 0 && type == ARDOUR::LXVST) {
2074                 type = ARDOUR::Windows_VST;
2075                 plugin = find_plugin (_session, prop->value(), type);
2076         }
2077 #endif
2078
2079         if (plugin == 0) {
2080                 error << string_compose(
2081                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2082                           "Perhaps it was removed or moved since it was last used."),
2083                         prop->value())
2084                       << endmsg;
2085                 return -1;
2086         }
2087
2088         if (type == ARDOUR::Lua) {
2089                 XMLNode *ls = node.child (plugin->state_node_name().c_str());
2090                 // we need to load the script to set the name and parameters.
2091                 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
2092                 if (ls && lp) {
2093                         lp->set_script_from_state (*ls);
2094                 }
2095         }
2096
2097         // The name of the PluginInsert comes from the plugin, nothing else
2098         _name = plugin->get_info()->name;
2099
2100         uint32_t count = 1;
2101
2102         // Processor::set_state() will set this, but too late
2103         // for it to be available when setting up plugin
2104         // state. We can't call Processor::set_state() until
2105         // the plugins themselves are created and added.
2106
2107         set_id (node);
2108
2109         if (_plugins.empty()) {
2110                 /* if we are adding the first plugin, we will need to set
2111                    up automatable controls.
2112                 */
2113                 add_plugin (plugin);
2114                 create_automatable_parameters ();
2115                 set_control_ids (node, version);
2116         }
2117
2118         if ((prop = node.property ("count")) != 0) {
2119                 sscanf (prop->value().c_str(), "%u", &count);
2120         }
2121
2122         if (_plugins.size() != count) {
2123                 for (uint32_t n = 1; n < count; ++n) {
2124                         add_plugin (plugin_factory (plugin));
2125                 }
2126         }
2127
2128         Processor::set_state (node, version);
2129
2130         PBD::ID new_id = this->id();
2131         PBD::ID old_id = this->id();
2132
2133         if ((prop = node.property ("id")) != 0) {
2134                 old_id = prop->value ();
2135         }
2136
2137         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2138
2139                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2140                    and set all plugins to the same state.
2141                 */
2142
2143                 if ((*niter)->name() == plugin->state_node_name()) {
2144
2145                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2146                                 /* Plugin state can include external files which are named after the ID.
2147                                  *
2148                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
2149                                  * been changed, so we need to use the old ID from the XML to load the
2150                                  * state and then update the ID.
2151                                  *
2152                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
2153                                  * but we need to call set_insert_id() to clear the cached plugin-state
2154                                  * and force a change.
2155                                  */
2156                                 if (!regenerate_xml_or_string_ids ()) {
2157                                         (*i)->set_insert_id (new_id);
2158                                 } else {
2159                                         (*i)->set_insert_id (old_id);
2160                                 }
2161
2162                                 (*i)->set_state (**niter, version);
2163
2164                                 if (regenerate_xml_or_string_ids ()) {
2165                                         (*i)->set_insert_id (new_id);
2166                                 }
2167                         }
2168
2169                         break;
2170                 }
2171         }
2172
2173         if (version < 3000) {
2174
2175                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2176                    this is all handled by Automatable
2177                 */
2178
2179                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2180                         if ((*niter)->name() == "Redirect") {
2181                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2182                                 Processor::set_state (**niter, version);
2183                                 break;
2184                         }
2185                 }
2186
2187                 set_parameter_state_2X (node, version);
2188         }
2189
2190         if ((prop = node.property (X_("custom"))) != 0) {
2191                 _custom_cfg = string_is_affirmative (prop->value());
2192         }
2193
2194         uint32_t in_maps = 0;
2195         uint32_t out_maps = 0;
2196         XMLNodeList kids = node.children ();
2197         for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2198                 if ((*i)->name() == X_("ConfiguredOutput")) {
2199                         _custom_out = ChanCount(**i);
2200                 }
2201                 if ((*i)->name() == X_("PresetOutput")) {
2202                         _preset_out = ChanCount(**i);
2203                 }
2204                 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2205                         long pc = atol (&((*i)->name().c_str()[9]));
2206                         if (pc >=0 && pc <= get_count()) {
2207                                 _in_map[pc] = ChanMapping (**i);
2208                                 ++in_maps;
2209                         }
2210                 }
2211                 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2212                         long pc = atol (&((*i)->name().c_str()[10]));
2213                         if (pc >=0 && pc <= get_count()) {
2214                                 _out_map[pc] = ChanMapping (**i);
2215                                 ++out_maps;
2216                         }
2217                 }
2218                 if ((*i)->name () ==  "ThruMap") {
2219                                 _thru_map = ChanMapping (**i);
2220                 }
2221
2222                 // sidechain is a Processor (IO)
2223                 if ((*i)->name () ==  Processor::state_node_name) {
2224                         if (!_sidechain) {
2225                                 add_sidechain (0);
2226                         }
2227                         _sidechain->set_state (**i, version);
2228                 }
2229         }
2230
2231         if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2232                 _maps_from_state = true;
2233         }
2234
2235         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2236                 if (active()) {
2237                         (*i)->activate ();
2238                 } else {
2239                         (*i)->deactivate ();
2240                 }
2241         }
2242
2243         PluginConfigChanged (); /* EMIT SIGNAL */
2244         return 0;
2245 }
2246
2247 void
2248 PluginInsert::update_id (PBD::ID id)
2249 {
2250         set_id (id.to_s());
2251         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2252                 (*i)->set_insert_id (id);
2253         }
2254 }
2255
2256 void
2257 PluginInsert::set_state_dir (const std::string& d)
2258 {
2259         // state() only saves the state of the first plugin
2260         _plugins[0]->set_state_dir (d);
2261 }
2262
2263 void
2264 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2265 {
2266         XMLNodeList nlist = node.children();
2267         XMLNodeIterator niter;
2268
2269         /* look for port automation node */
2270
2271         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2272
2273                 if ((*niter)->name() != port_automation_node_name) {
2274                         continue;
2275                 }
2276
2277                 XMLNodeList cnodes;
2278                 XMLProperty *cprop;
2279                 XMLNodeConstIterator iter;
2280                 XMLNode *child;
2281                 const char *port;
2282                 uint32_t port_id;
2283
2284                 cnodes = (*niter)->children ("port");
2285
2286                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2287
2288                         child = *iter;
2289
2290                         if ((cprop = child->property("number")) != 0) {
2291                                 port = cprop->value().c_str();
2292                         } else {
2293                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2294                                 continue;
2295                         }
2296
2297                         sscanf (port, "%" PRIu32, &port_id);
2298
2299                         if (port_id >= _plugins[0]->parameter_count()) {
2300                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2301                                 continue;
2302                         }
2303
2304                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2305                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2306
2307                         if (c && c->alist()) {
2308                                 if (!child->children().empty()) {
2309                                         c->alist()->set_state (*child->children().front(), version);
2310
2311                                         /* In some cases 2.X saves lists with min_yval and max_yval
2312                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
2313                                            in A3 because these min/max values are used to compute
2314                                            where GUI control points should be drawn.  If we see such
2315                                            values, `correct' them to the min/max of the appropriate
2316                                            parameter.
2317                                         */
2318
2319                                         float min_y = c->alist()->get_min_y ();
2320                                         float max_y = c->alist()->get_max_y ();
2321
2322                                         ParameterDescriptor desc;
2323                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
2324
2325                                         if (min_y == FLT_MIN) {
2326                                                 min_y = desc.lower;
2327                                         }
2328
2329                                         if (max_y == FLT_MAX) {
2330                                                 max_y = desc.upper;
2331                                         }
2332
2333                                         c->alist()->set_yrange (min_y, max_y);
2334                                 }
2335                         } else {
2336                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2337                         }
2338                 }
2339
2340                 /* done */
2341
2342                 break;
2343         }
2344 }
2345
2346
2347 string
2348 PluginInsert::describe_parameter (Evoral::Parameter param)
2349 {
2350         if (param.type() == PluginAutomation) {
2351                 return _plugins[0]->describe_parameter (param);
2352         } else if (param.type() == PluginPropertyAutomation) {
2353                 boost::shared_ptr<AutomationControl> c(automation_control(param));
2354                 if (c && !c->desc().label.empty()) {
2355                         return c->desc().label;
2356                 }
2357         }
2358         return Automatable::describe_parameter(param);
2359 }
2360
2361 ARDOUR::framecnt_t
2362 PluginInsert::signal_latency() const
2363 {
2364         if (_user_latency) {
2365                 return _user_latency;
2366         }
2367
2368         return _plugins[0]->signal_latency ();
2369 }
2370
2371 ARDOUR::PluginType
2372 PluginInsert::type ()
2373 {
2374        return plugin()->get_info()->type;
2375 }
2376
2377 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
2378                                             const Evoral::Parameter&          param,
2379                                             const ParameterDescriptor&        desc,
2380                                             boost::shared_ptr<AutomationList> list)
2381         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2382         , _plugin (p)
2383 {
2384         if (alist()) {
2385                 alist()->reset_default (desc.normal);
2386                 if (desc.toggled) {
2387                         list->set_interpolation(Evoral::ControlList::Discrete);
2388                 }
2389         }
2390
2391         if (desc.toggled) {
2392                 set_flags(Controllable::Toggle);
2393         }
2394 }
2395
2396 /** @param val `user' value */
2397 void
2398 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2399 {
2400         if (writable()) {
2401                 _set_value (user_val, group_override);
2402         }
2403 }
2404 void
2405 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2406 {
2407         /* used only by automation playback */
2408         _set_value (user_val, Controllable::NoGroup);
2409 }
2410
2411 void
2412 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2413 {
2414         /* FIXME: probably should be taking out some lock here.. */
2415
2416         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2417                 (*i)->set_parameter (_list->parameter().id(), user_val);
2418         }
2419
2420         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2421         if (iasp) {
2422                 iasp->set_parameter (_list->parameter().id(), user_val);
2423         }
2424
2425         AutomationControl::set_value (user_val, group_override);
2426 }
2427
2428 void
2429 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2430 {
2431         AutomationControl::set_value (user_val, Controllable::NoGroup);
2432 }
2433
2434 XMLNode&
2435 PluginInsert::PluginControl::get_state ()
2436 {
2437         stringstream ss;
2438
2439         XMLNode& node (AutomationControl::get_state());
2440         ss << parameter().id();
2441         node.add_property (X_("parameter"), ss.str());
2442 #ifdef LV2_SUPPORT
2443         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2444         if (lv2plugin) {
2445                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2446         }
2447 #endif
2448
2449         return node;
2450 }
2451
2452 /** @return `user' val */
2453 double
2454 PluginInsert::PluginControl::get_value () const
2455 {
2456         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2457
2458         if (!plugin) {
2459                 return 0.0;
2460         }
2461
2462         return plugin->get_parameter (_list->parameter().id());
2463 }
2464
2465 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
2466                                                             const Evoral::Parameter&          param,
2467                                                             const ParameterDescriptor&        desc,
2468                                                             boost::shared_ptr<AutomationList> list)
2469         : AutomationControl (p->session(), param, desc, list)
2470         , _plugin (p)
2471 {
2472         if (alist()) {
2473                 alist()->set_yrange (desc.lower, desc.upper);
2474                 alist()->reset_default (desc.normal);
2475         }
2476
2477         if (desc.toggled) {
2478                 set_flags(Controllable::Toggle);
2479         }
2480 }
2481
2482 void
2483 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2484 {
2485         if (writable()) {
2486                 set_value_unchecked (user_val);
2487         }
2488 }
2489
2490 void
2491 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2492 {
2493         /* Old numeric set_value(), coerce to appropriate datatype if possible.
2494            This is lossy, but better than nothing until Ardour's automation system
2495            can handle various datatypes all the way down. */
2496         const Variant value(_desc.datatype, user_val);
2497         if (value.type() == Variant::NOTHING) {
2498                 error << "set_value(double) called for non-numeric property" << endmsg;
2499                 return;
2500         }
2501
2502         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2503                 (*i)->set_property(_list->parameter().id(), value);
2504         }
2505
2506         _value = value;
2507         AutomationControl::set_value (user_val, Controllable::NoGroup);
2508 }
2509
2510 XMLNode&
2511 PluginInsert::PluginPropertyControl::get_state ()
2512 {
2513         stringstream ss;
2514
2515         XMLNode& node (AutomationControl::get_state());
2516         ss << parameter().id();
2517         node.add_property (X_("property"), ss.str());
2518         node.remove_property (X_("value"));
2519
2520         return node;
2521 }
2522
2523 double
2524 PluginInsert::PluginPropertyControl::get_value () const
2525 {
2526         return _value.to_double();
2527 }
2528
2529 boost::shared_ptr<Plugin>
2530 PluginInsert::get_impulse_analysis_plugin()
2531 {
2532         boost::shared_ptr<Plugin> ret;
2533         if (_impulseAnalysisPlugin.expired()) {
2534                 // LV2 in particular uses various _session params
2535                 // during init() -- most notably block_size..
2536                 // not great.
2537                 ret = plugin_factory(_plugins[0]);
2538                 ret->configure_io (internal_input_streams (), internal_output_streams ());
2539                 _impulseAnalysisPlugin = ret;
2540         } else {
2541                 ret = _impulseAnalysisPlugin.lock();
2542         }
2543
2544         return ret;
2545 }
2546
2547 void
2548 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2549 {
2550         // called from outside the audio thread, so this should be safe
2551         // only do audio as analysis is (currently) only for audio plugins
2552         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, internal_input_streams().n_audio(),  nframes);
2553         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2554
2555         _signal_analysis_collected_nframes   = 0;
2556         _signal_analysis_collect_nframes_max = nframes;
2557 }
2558
2559 /** Add a plugin to our list */
2560 void
2561 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2562 {
2563         plugin->set_insert_id (this->id());
2564
2565         if (_plugins.empty()) {
2566                 /* first (and probably only) plugin instance - connect to relevant signals */
2567
2568                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2569                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2570                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2571                 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2572                 // cache sidechain port count
2573                 _cached_sidechain_pins.reset ();
2574                 const ChanCount& nis (plugin->get_info()->n_inputs);
2575                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2576                         for (uint32_t in = 0; in < nis.get (*t); ++in) {
2577                                 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2578                                 if (iod.is_sidechain) {
2579                                         _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2580                                 }
2581                         }
2582                 }
2583         }
2584 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2585         boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2586         if (vst) {
2587                 vst->set_insert (this, _plugins.size ());
2588         }
2589 #endif
2590         _plugins.push_back (plugin);
2591 }
2592
2593 void
2594 PluginInsert::realtime_handle_transport_stopped ()
2595 {
2596         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2597                 (*i)->realtime_handle_transport_stopped ();
2598         }
2599 }
2600
2601 void
2602 PluginInsert::realtime_locate ()
2603 {
2604         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2605                 (*i)->realtime_locate ();
2606         }
2607 }
2608
2609 void
2610 PluginInsert::monitoring_changed ()
2611 {
2612         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2613                 (*i)->monitoring_changed ();
2614         }
2615 }
2616
2617 void
2618 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2619 {
2620         // this is called in RT context, LatencyChanged is emitted after run()
2621         _latency_changed = true;
2622 }
2623
2624 void
2625 PluginInsert::start_touch (uint32_t param_id)
2626 {
2627         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2628         if (ac) {
2629                 ac->start_touch (session().audible_frame());
2630         }
2631 }
2632
2633 void
2634 PluginInsert::end_touch (uint32_t param_id)
2635 {
2636         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2637         if (ac) {
2638                 ac->stop_touch (true, session().audible_frame());
2639         }
2640 }
2641
2642 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2643 {
2644         switch (m.method) {
2645                 case PluginInsert::Impossible: o << "Impossible"; break;
2646                 case PluginInsert::Delegate:   o << "Delegate"; break;
2647                 case PluginInsert::NoInputs:   o << "NoInputs"; break;
2648                 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2649                 case PluginInsert::Replicate:  o << "Replicate"; break;
2650                 case PluginInsert::Split:      o << "Split"; break;
2651                 case PluginInsert::Hide:       o << "Hide"; break;
2652         }
2653         o << " cnt: " << m.plugins
2654                 << (m.strict_io ? " strict-io" : "")
2655                 << (m.custom_cfg ? " custom-cfg" : "");
2656         if (m.method == PluginInsert::Hide) {
2657                 o << " hide: " << m.hide;
2658         }
2659         o << "\n";
2660         return o;
2661 }