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