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