libs/ardour/plugin_insert.cc

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