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 bool
1196 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1197                 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1198 {
1199         if (_configured) { return false; }
1200         _configured_in = in;
1201         _configured_out = out;
1202         _in_map[0] = im;
1203         _out_map[0] = om;
1204         _thru_map = tm;
1205         _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1206         return true;
1207 }
1208
1209 ChanMapping
1210 PluginInsert::input_map () const
1211 {
1212         ChanMapping rv;
1213         uint32_t pc = 0;
1214         for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1215                 ChanMapping m (i->second);
1216                 const ChanMapping::Mappings& mp ((*i).second.mappings());
1217                 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1218                         for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1219                                 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1220                         }
1221                 }
1222         }
1223         return rv;
1224 }
1225
1226 ChanMapping
1227 PluginInsert::output_map () const
1228 {
1229         ChanMapping rv;
1230         uint32_t pc = 0;
1231         for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1232                 ChanMapping m (i->second);
1233                 const ChanMapping::Mappings& mp ((*i).second.mappings());
1234                 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1235                         for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1236                                 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1237                         }
1238                 }
1239         }
1240         if (has_midi_bypass ()) {
1241                 rv.set (DataType::MIDI, 0, 0);
1242         }
1243
1244         return rv;
1245 }
1246
1247 bool
1248 PluginInsert::has_midi_bypass () const
1249 {
1250         if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1251                         && natural_output_streams ().n_midi () == 0) {
1252                 return true;
1253         }
1254         return false;
1255 }
1256
1257 bool
1258 PluginInsert::has_midi_thru () const
1259 {
1260         if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1261                         && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1262                 return true;
1263         }
1264         return false;
1265 }
1266
1267 #ifdef MIXBUS
1268 bool
1269 PluginInsert::is_channelstrip () const {
1270         return _plugins.front()->is_channelstrip();
1271 }
1272 #endif
1273
1274 bool
1275 PluginInsert::check_inplace ()
1276 {
1277         bool inplace_ok = !_plugins.front()->inplace_broken ();
1278
1279         if (_thru_map.n_total () > 0) {
1280                 // TODO once midi-bypass is part of the mapping, ignore it
1281                 inplace_ok = false;
1282         }
1283
1284         if (_match.method == Split && inplace_ok) {
1285                 assert (get_count() == 1);
1286                 assert (_in_map.size () == 1);
1287                 if (!_out_map[0].is_monotonic ()) {
1288                         inplace_ok = false;
1289                 }
1290                 if (_configured_internal != _configured_in) {
1291                         /* no sidechain -- TODO we could allow this with
1292                          * some more logic in PluginInsert::connect_and_run().
1293                          *
1294                          * PluginInsert::reset_map() already maps it.
1295                          */
1296                         inplace_ok = false;
1297                 }
1298                 /* check mapping */
1299                 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1300                         if (_configured_internal.get (*t) == 0) {
1301                                 continue;
1302                         }
1303                         bool valid;
1304                         uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1305                         if (!valid || first_idx != 0) {
1306                                 // so far only allow to copy the *first* stream's buffer to others
1307                                 inplace_ok = false;
1308                         } else {
1309                                 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1310                                         uint32_t idx = _in_map[0].get (*t, i, &valid);
1311                                         if (valid && idx != first_idx) {
1312                                                 inplace_ok = false;
1313                                                 break;
1314                                         }
1315                                 }
1316                         }
1317                 }
1318
1319                 if (inplace_ok) {
1320                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1321                         return false;
1322                 }
1323         }
1324
1325         for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1326                 if (!_in_map[pc].is_monotonic ()) {
1327                         inplace_ok = false;
1328                 }
1329                 if (!_out_map[pc].is_monotonic ()) {
1330                         inplace_ok = false;
1331                 }
1332         }
1333         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1334         return !inplace_ok; // no-inplace
1335 }
1336
1337 bool
1338 PluginInsert::sanitize_maps ()
1339 {
1340         bool changed = false;
1341         /* strip dead wood */
1342         PinMappings new_ins;
1343         PinMappings new_outs;
1344         ChanMapping new_thru;
1345
1346         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1347                 ChanMapping new_in;
1348                 ChanMapping new_out;
1349                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1350                         for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1351                                 bool valid;
1352                                 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1353                                 if (valid && idx < _configured_internal.get (*t)) {
1354                                         new_in.set (*t, i, idx);
1355                                 }
1356                         }
1357                         for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1358                                 bool valid;
1359                                 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1360                                 if (valid && idx < _configured_out.get (*t)) {
1361                                         new_out.set (*t, o, idx);
1362                                 }
1363                         }
1364                 }
1365                 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1366                         changed = true;
1367                 }
1368                 new_ins[pc] = new_in;
1369                 new_outs[pc] = new_out;
1370         }
1371
1372         /* prevent dup output assignments */
1373         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1374                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1375                         bool mapped = false;
1376                         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1377                                 bool valid;
1378                                 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1379                                 if (valid && mapped) {
1380                                         new_outs[pc].unset (*t, idx);
1381                                 } else if (valid) {
1382                                         mapped = true;
1383                                 }
1384                         }
1385                 }
1386         }
1387
1388         /* remove excess thru */
1389         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1390                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1391                         bool valid;
1392                         uint32_t idx = _thru_map.get (*t, o, &valid);
1393                         if (valid && idx < _configured_internal.get (*t)) {
1394                                 new_thru.set (*t, o, idx);
1395                         }
1396                 }
1397         }
1398
1399         /* prevent out + thru,  existing plugin outputs override thru */
1400         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1401                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1402                         bool mapped = false;
1403                         bool valid;
1404                         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1405                                 new_outs[pc].get_src (*t, o, &mapped);
1406                                 if (mapped) { break; }
1407                         }
1408                         if (!mapped) { continue; }
1409                         uint32_t idx = new_thru.get (*t, o, &valid);
1410                         if (mapped) {
1411                                 new_thru.unset (*t, idx);
1412                         }
1413                 }
1414         }
1415
1416         if (has_midi_bypass ()) {
1417                 // TODO: include midi-bypass in the thru set,
1418                 // remove dedicated handling.
1419                 new_thru.unset (DataType::MIDI, 0);
1420         }
1421
1422         if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1423                 changed = true;
1424         }
1425         _in_map = new_ins;
1426         _out_map = new_outs;
1427         _thru_map = new_thru;
1428
1429         return changed;
1430 }
1431
1432 bool
1433 PluginInsert::reset_map (bool emit)
1434 {
1435         const PinMappings old_in (_in_map);
1436         const PinMappings old_out (_out_map);
1437
1438         _in_map.clear ();
1439         _out_map.clear ();
1440         _thru_map = ChanMapping ();
1441
1442         /* build input map */
1443         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1444                 uint32_t sc = 0; // side-chain round-robin (all instances)
1445                 uint32_t pc = 0;
1446                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1447                         const uint32_t nis = natural_input_streams ().get(*t);
1448                         const uint32_t stride = nis - sidechain_input_pins().get (*t);
1449
1450                         /* SC inputs are last in the plugin-insert.. */
1451                         const uint32_t sc_start = _configured_in.get (*t);
1452                         const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1453                         /* ...but may not be at the end of the plugin ports.
1454                          * in case the side-chain is not the last port, shift connections back.
1455                          * and connect to side-chain
1456                          */
1457                         uint32_t shift = 0;
1458                         uint32_t ic = 0; // split inputs
1459                         const uint32_t cend = _configured_in.get (*t);
1460
1461                         for (uint32_t in = 0; in < nis; ++in) {
1462                                 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1463                                 if (iod.is_sidechain) {
1464                                         /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1465                                         if (sc_len > 0) {// side-chain may be hidden
1466                                                 _in_map[pc].set (*t, in, sc_start + sc);
1467                                                 sc = (sc + 1) % sc_len;
1468                                         }
1469                                         ++shift;
1470                                 } else {
1471                                         if (_match.method == Split) {
1472                                                 if (cend == 0) { continue; }
1473                                                 if (_strict_io && ic + stride * pc >= cend) {
1474                                                         break;
1475                                                 }
1476                                                 /* connect *no* sidechain sinks in round-robin fashion */
1477                                                 _in_map[pc].set (*t, in, ic + stride * pc);
1478                                                 if (_strict_io && (ic + 1) == cend) {
1479                                                         break;
1480                                                 }
1481                                                 ic = (ic + 1) % cend;
1482                                         } else {
1483                                                 uint32_t s = in - shift;
1484                                                 if (stride * pc + s < cend) {
1485                                                         _in_map[pc].set (*t, in, s + stride * pc);
1486                                                 }
1487                                         }
1488                                 }
1489                         }
1490                 }
1491         }
1492
1493         /* build output map */
1494         uint32_t pc = 0;
1495         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1496                 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1497                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1498                         _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1499                 }
1500         }
1501
1502         sanitize_maps ();
1503         if (old_in == _in_map && old_out == _out_map) {
1504                 return false;
1505         }
1506         if (emit) {
1507                 PluginMapChanged (); /* EMIT SIGNAL */
1508                 _mapping_changed = true;
1509                 _session.set_dirty();
1510         }
1511         return true;
1512 }
1513
1514 bool
1515 PluginInsert::configure_io (ChanCount in, ChanCount out)
1516 {
1517         Match old_match = _match;
1518         ChanCount old_in;
1519         ChanCount old_internal;
1520         ChanCount old_out;
1521         ChanCount old_pins;
1522
1523         old_pins = natural_input_streams();
1524         old_in = _configured_in;
1525         old_out = _configured_out;
1526         old_internal = _configured_internal;
1527
1528         _configured_in = in;
1529         _configured_internal = in;
1530         _configured_out = out;
1531
1532         if (_sidechain) {
1533                 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1534                  * (currently _sidechain->configure_io always succeeds
1535                  *  since Processor::configure_io() succeeds)
1536                  */
1537                 if (!_sidechain->configure_io (in, out)) {
1538                         DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1539                         return false;
1540                 }
1541                 _configured_internal += _sidechain->input()->n_ports();
1542
1543                 // include (static_cast<Route*>owner())->name() ??
1544                 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1545         }
1546
1547         /* get plugin configuration */
1548         _match = private_can_support_io_configuration (in, out);
1549 #ifndef NDEBUG
1550         if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1551                 DEBUG_STR_DECL(a);
1552                 DEBUG_STR_APPEND(a, string_compose ("%1: ",  name()));
1553                 DEBUG_STR_APPEND(a, _match);
1554                 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1555         }
1556 #endif
1557
1558         /* set the matching method and number of plugins that we will use to meet this configuration */
1559         if (set_count (_match.plugins) == false) {
1560                 PluginIoReConfigure (); /* EMIT SIGNAL */
1561                 _configured = false;
1562                 return false;
1563         }
1564
1565         /* configure plugins */
1566         switch (_match.method) {
1567         case Split:
1568         case Hide:
1569                 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1570                         PluginIoReConfigure (); /* EMIT SIGNAL */
1571                         _configured = false;
1572                         return false;
1573                 }
1574                 break;
1575         case Delegate:
1576                 {
1577                         ChanCount din (_configured_internal);
1578                         ChanCount dout (din); // hint
1579                         if (_custom_cfg) {
1580                                 if (_custom_sinks.n_total () > 0) {
1581                                         din = _custom_sinks;
1582                                 }
1583                                 dout = _custom_out;
1584                         } else if (_preset_out.n_audio () > 0) {
1585                                 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1586                         } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1587                                 dout.set (DataType::AUDIO, 2);
1588                         }
1589                         if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1590                         ChanCount useins;
1591                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1592                         bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1593                         assert (r);
1594                         if (useins.n_audio() == 0) {
1595                                 useins = din;
1596                         }
1597                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1598
1599                         if (_plugins.front()->configure_io (useins, dout) == false) {
1600                                 PluginIoReConfigure (); /* EMIT SIGNAL */
1601                                 _configured = false;
1602                                 return false;
1603                         }
1604                         if (!_custom_cfg) {
1605                                 _custom_sinks = din;
1606                         }
1607                 }
1608                 break;
1609         default:
1610                 if (_plugins.front()->configure_io (in, out) == false) {
1611                         PluginIoReConfigure (); /* EMIT SIGNAL */
1612                         _configured = false;
1613                         return false;
1614                 }
1615                 break;
1616         }
1617
1618         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",
1619                                 name (),
1620                                 _configured ? "Y" : "N",
1621                                 _maps_from_state ? "Y" : "N",
1622                                 old_in == in ? "==" : "!=",
1623                                 old_out == out ? "==" : "!=",
1624                                 old_pins == natural_input_streams () ? "==" : "!=",
1625                                 old_match.method == _match.method ? "==" : "!=",
1626                                 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1627                                 _in_map.size() == get_count () ? "==" : "!=",
1628                                 _out_map.size() == get_count () ? "==" : "!="
1629                                 ));
1630
1631         bool mapping_changed = false;
1632         if (old_in == in && old_out == out
1633                         && _configured
1634                         && old_pins == natural_input_streams ()
1635                         && old_match.method == _match.method
1636                         && old_match.custom_cfg == _match.custom_cfg
1637                         && _in_map.size() == _out_map.size()
1638                         && _in_map.size() == get_count ()
1639                  ) {
1640                 assert (_maps_from_state == false);
1641                 /* If the configuration has not changed, keep the mapping */
1642                 mapping_changed = sanitize_maps ();
1643         } else if (_match.custom_cfg && _configured) {
1644                 assert (_maps_from_state == false);
1645                 /* don't touch the map in manual mode */
1646                 mapping_changed = sanitize_maps ();
1647         } else {
1648 #ifdef MIXBUS
1649                 if (is_channelstrip ()) {
1650                         /* fake channel map - for wire display */
1651                         _in_map.clear ();
1652                         _out_map.clear ();
1653                         _thru_map = ChanMapping ();
1654                         _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1655                         _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1656                         /* set "thru" map for in-place forward of audio */
1657                         for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1658                                 _thru_map.set (DataType::AUDIO, i, i);
1659                         }
1660                         /* and midi (after implicit 1st channel bypass) */
1661                         for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1662                                 _thru_map.set (DataType::MIDI, i, i);
1663                         }
1664                 } else
1665 #endif
1666                 if (_maps_from_state && old_in == in && old_out == out) {
1667                         mapping_changed = true;
1668                         sanitize_maps ();
1669                 } else {
1670                         /* generate a new mapping */
1671                         mapping_changed = reset_map (false);
1672                 }
1673                 _maps_from_state = false;
1674         }
1675
1676         if (mapping_changed) {
1677                 PluginMapChanged (); /* EMIT SIGNAL */
1678
1679 #ifndef NDEBUG
1680                 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1681                         uint32_t pc = 0;
1682                         DEBUG_STR_DECL(a);
1683                         DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1684                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1685                                 if (pc > 0) {
1686                         DEBUG_STR_APPEND(a, "----><----\n");
1687                                 }
1688                                 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1689                                 DEBUG_STR_APPEND(a, " * Inputs:\n");
1690                                 DEBUG_STR_APPEND(a, _in_map[pc]);
1691                                 DEBUG_STR_APPEND(a, " * Outputs:\n");
1692                                 DEBUG_STR_APPEND(a, _out_map[pc]);
1693                         }
1694                         DEBUG_STR_APPEND(a, " * Thru:\n");
1695                         DEBUG_STR_APPEND(a, _thru_map);
1696                         DEBUG_STR_APPEND(a, "-------->>--------\n");
1697                         DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1698                 }
1699 #endif
1700         }
1701
1702         _no_inplace = check_inplace ();
1703         _mapping_changed = false;
1704
1705         /* only the "noinplace_buffers" thread buffers need to be this large,
1706          * this can be optimized. other buffers are fine with
1707          * ChanCount::max (natural_input_streams (), natural_output_streams())
1708          * and route.cc's max (configured_in, configured_out)
1709          *
1710          * no-inplace copies "thru" outputs (to emulate in-place) for
1711          * all outputs (to prevent overwrite) into a temporary space
1712          * which also holds input buffers (in case the plugin does process
1713          * in-place and overwrites those).
1714          *
1715          * this buffers need to be at least as
1716          *   natural_input_streams () + possible outputs.
1717          *
1718          * sidechain inputs add a constraint on the input:
1719          * configured input + sidechain (=_configured_internal)
1720          *
1721          * NB. this also satisfies
1722          * max (natural_input_streams(), natural_output_streams())
1723          * which is needed for silence runs
1724          */
1725         _required_buffers = ChanCount::max (_configured_internal,
1726                         natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1727
1728         if (old_in != in || old_out != out || old_internal != _configured_internal
1729                         || old_pins != natural_input_streams ()
1730                         || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1731                  ) {
1732                 PluginIoReConfigure (); /* EMIT SIGNAL */
1733         }
1734
1735         _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1736         _latency_changed = true;
1737
1738         // we don't know the analysis window size, so we must work with the
1739         // current buffer size here. each request for data fills in these
1740         // buffers and the analyser makes sure it gets enough data for the
1741         // analysis window
1742         session().ensure_buffer_set (_signal_analysis_inputs, in);
1743         //_signal_analysis_inputs.set_count (in);
1744
1745         session().ensure_buffer_set (_signal_analysis_outputs, out);
1746         //_signal_analysis_outputs.set_count (out);
1747
1748         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1749
1750         _configured = true;
1751         return Processor::configure_io (in, out);
1752 }
1753
1754 /** Decide whether this PluginInsert can support a given IO configuration.
1755  *  To do this, we run through a set of possible solutions in rough order of
1756  *  preference.
1757  *
1758  *  @param in Required input channel count.
1759  *  @param out Filled in with the output channel count if we return true.
1760  *  @return true if the given IO configuration can be supported.
1761  */
1762 bool
1763 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1764 {
1765         if (_sidechain) {
1766                 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1767         }
1768         return private_can_support_io_configuration (in, out).method != Impossible;
1769 }
1770
1771 PluginInsert::Match
1772 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1773 {
1774         if (!_custom_cfg && _preset_out.n_audio () > 0) {
1775                 // preseed hint (for variable i/o)
1776                 out.set (DataType::AUDIO, _preset_out.n_audio ());
1777         }
1778
1779         Match rv = internal_can_support_io_configuration (in, out);
1780
1781         if (!_custom_cfg && _preset_out.n_audio () > 0) {
1782                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
1783                 out.set (DataType::AUDIO, _preset_out.n_audio ());
1784         }
1785         return rv;
1786 }
1787
1788 /** A private version of can_support_io_configuration which returns the method
1789  *  by which the configuration can be matched, rather than just whether or not
1790  *  it can be.
1791  */
1792 PluginInsert::Match
1793 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1794 {
1795         if (_plugins.empty()) {
1796                 return Match();
1797         }
1798
1799 #ifdef MIXBUS
1800         if (is_channelstrip ()) {
1801                 out = inx;
1802                 return Match (ExactMatch, 1);
1803         }
1804 #endif
1805
1806         /* if a user specified a custom cfg, so be it. */
1807         if (_custom_cfg) {
1808                 PluginInfoPtr info = _plugins.front()->get_info();
1809                 out = _custom_out;
1810                 if (info->reconfigurable_io()) {
1811                         return Match (Delegate, 1, _strict_io, true);
1812                 } else {
1813                         return Match (ExactMatch, get_count(), _strict_io, true);
1814                 }
1815         }
1816
1817         /* try automatic configuration */
1818         Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1819
1820         PluginInfoPtr info = _plugins.front()->get_info();
1821         ChanCount inputs  = info->n_inputs;
1822         ChanCount outputs = info->n_outputs;
1823
1824         /* handle case strict-i/o */
1825         if (_strict_io && m.method != Impossible) {
1826                 m.strict_io = true;
1827
1828                 /* special case MIDI instruments */
1829                 if (needs_midi_input ()) {
1830                         // output = midi-bypass + at most master-out channels.
1831                         ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1832                         max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1833                         out = ChanCount::min (out, max_out);
1834                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
1835                         return m;
1836                 }
1837
1838                 switch (m.method) {
1839                         case NoInputs:
1840                                 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1841                                         /* replicate processor to match output count (generators and such)
1842                                          * at least enough to feed every output port. */
1843                                         uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1844                                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1845                                                 uint32_t nout = outputs.get (*t);
1846                                                 if (nout == 0 || inx.get(*t) == 0) { continue; }
1847                                                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1848                                         }
1849                                         out = inx;
1850                                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
1851                                         return Match (Replicate, f, _strict_io);
1852                                 }
1853                                 break;
1854                         default:
1855                                 break;
1856                 }
1857
1858                 out = inx;
1859                 return m;
1860         }
1861
1862         if (m.method != Impossible) {
1863                 return m;
1864         }
1865
1866         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1867
1868         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
1869
1870         if (info->reconfigurable_io()) {
1871                 ChanCount useins;
1872                 out = inx; // hint
1873                 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1874                 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1875                 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
1876                 if (!r) {
1877                         // houston, we have a problem.
1878                         return Match (Impossible, 0);
1879                 }
1880                 return Match (Delegate, 1, _strict_io);
1881         }
1882
1883         ChanCount midi_bypass;
1884         if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1885                 midi_bypass.set (DataType::MIDI, 1);
1886         }
1887
1888         // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1889         uint32_t f = 0;
1890         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1891                 uint32_t nin = ns_inputs.get (*t);
1892                 uint32_t nout = outputs.get (*t);
1893                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1894                 // prefer floor() so the count won't overly increase IFF (nin < nout)
1895                 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1896         }
1897         if (f > 0 && outputs * f >= _configured_out) {
1898                 out = outputs * f + midi_bypass;
1899                 return Match (Replicate, f, _strict_io);
1900         }
1901
1902         // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1903         f = 0;
1904         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1905                 uint32_t nin = ns_inputs.get (*t);
1906                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1907                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1908         }
1909         if (f > 0) {
1910                 out = outputs * f + midi_bypass;
1911                 return Match (Replicate, f, _strict_io);
1912         }
1913
1914         // add at least as many plugins needed to connect all inputs
1915         f = 1;
1916         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1917                 uint32_t nin = inputs.get (*t);
1918                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1919                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1920         }
1921         out = outputs * f + midi_bypass;
1922         return Match (Replicate, f, _strict_io);
1923 }
1924
1925 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1926 PluginInsert::Match
1927 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1928 {
1929         if (_plugins.empty()) {
1930                 return Match();
1931         }
1932
1933         PluginInfoPtr info = _plugins.front()->get_info();
1934         ChanCount in; in += inx;
1935         ChanCount midi_bypass;
1936
1937         if (info->reconfigurable_io()) {
1938                 /* Plugin has flexible I/O, so delegate to it
1939                  * pre-seed outputs, plugin tries closest match
1940                  */
1941                 out = in; // hint
1942                 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1943                 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1944                 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
1945                 if (!r) {
1946                         return Match (Impossible, 0);
1947                 }
1948                 return Match (Delegate, 1);
1949         }
1950
1951         ChanCount inputs  = info->n_inputs;
1952         ChanCount outputs = info->n_outputs;
1953         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1954
1955         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1956                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
1957                 midi_bypass.set (DataType::MIDI, 1);
1958         }
1959         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1960                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
1961                 in.set(DataType::MIDI, 0);
1962         }
1963
1964         // add internally provided sidechain ports
1965         ChanCount insc = in + sidechain_input_ports ();
1966
1967         bool no_inputs = true;
1968         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1969                 if (inputs.get (*t) != 0) {
1970                         no_inputs = false;
1971                         break;
1972                 }
1973         }
1974
1975         if (no_inputs) {
1976                 /* no inputs so we can take any input configuration since we throw it away */
1977                 out = outputs + midi_bypass;
1978                 return Match (NoInputs, 1);
1979         }
1980
1981         /* Plugin inputs match requested inputs + side-chain-ports exactly */
1982         if (inputs == insc) {
1983                 out = outputs + midi_bypass;
1984                 return Match (ExactMatch, 1);
1985         }
1986
1987         /* Plugin inputs matches without side-chain-pins */
1988         if (ns_inputs == in) {
1989                 out = outputs + midi_bypass;
1990                 return Match (ExactMatch, 1);
1991         }
1992
1993         /* We may be able to run more than one copy of the plugin within this insert
1994            to cope with the insert having more inputs than the plugin.
1995            We allow replication only for plugins with either zero or 1 inputs and outputs
1996            for every valid data type.
1997         */
1998
1999         uint32_t f             = 0;
2000         bool     can_replicate = true;
2001         for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
2002
2003                 // ignore side-chains
2004                 uint32_t nin = ns_inputs.get (*t);
2005
2006                 // No inputs of this type
2007                 if (nin == 0 && in.get(*t) == 0) {
2008                         continue;
2009                 }
2010
2011                 if (nin != 1 || outputs.get (*t) != 1) {
2012                         can_replicate = false;
2013                         break;
2014                 }
2015
2016                 // Potential factor not set yet
2017                 if (f == 0) {
2018                         f = in.get(*t) / nin;
2019                 }
2020
2021                 // Factor for this type does not match another type, can not replicate
2022                 if (f != (in.get(*t) / nin)) {
2023                         can_replicate = false;
2024                         break;
2025                 }
2026         }
2027
2028         if (can_replicate && f > 0) {
2029                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2030                         out.set (*t, outputs.get(*t) * f);
2031                 }
2032                 out += midi_bypass;
2033                 return Match (Replicate, f);
2034         }
2035
2036         /* If the processor has exactly one input of a given type, and
2037            the plugin has more, we can feed the single processor input
2038            to some or all of the plugin inputs.  This is rather
2039            special-case-y, but the 1-to-many case is by far the
2040            simplest.  How do I split thy 2 processor inputs to 3
2041            plugin inputs?  Let me count the ways ...
2042         */
2043
2044         bool can_split = true;
2045         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2046
2047                 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2048                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2049
2050                 if (!can_split_type && !nothing_to_do_for_type) {
2051                         can_split = false;
2052                 }
2053         }
2054
2055         if (can_split) {
2056                 out = outputs + midi_bypass;
2057                 return Match (Split, 1);
2058         }
2059
2060         /* If the plugin has more inputs than we want, we can `hide' some of them
2061            by feeding them silence.
2062         */
2063
2064         bool could_hide = false;
2065         bool cannot_hide = false;
2066         ChanCount hide_channels;
2067
2068         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2069                 if (inputs.get(*t) > in.get(*t)) {
2070                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2071                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2072                         could_hide = true;
2073                 } else if (inputs.get(*t) < in.get(*t)) {
2074                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2075                         cannot_hide = true;
2076                 }
2077         }
2078
2079         if (could_hide && !cannot_hide) {
2080                 out = outputs + midi_bypass;
2081                 return Match (Hide, 1, false, false, hide_channels);
2082         }
2083
2084         return Match (Impossible, 0);
2085 }
2086
2087
2088 XMLNode&
2089 PluginInsert::get_state ()
2090 {
2091         return state (true);
2092 }
2093
2094 XMLNode&
2095 PluginInsert::state (bool full)
2096 {
2097         XMLNode& node = Processor::state (full);
2098
2099         node.add_property("type", _plugins[0]->state_node_name());
2100         node.add_property("unique-id", _plugins[0]->unique_id());
2101         node.add_property("count", string_compose("%1", _plugins.size()));
2102
2103         /* remember actual i/o configuration (for later placeholder
2104          * in case the plugin goes missing) */
2105         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2106         node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2107         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2108         node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2109
2110         /* save custom i/o config */
2111         node.add_property("custom", _custom_cfg ? "yes" : "no");
2112         for (uint32_t pc = 0; pc < get_count(); ++pc) {
2113                 char tmp[128];
2114                 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2115                 node.add_child_nocopy (* _in_map[pc].state (tmp));
2116                 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2117                 node.add_child_nocopy (* _out_map[pc].state (tmp));
2118         }
2119         node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2120
2121         if (_sidechain) {
2122                 node.add_child_nocopy (_sidechain->state (full));
2123         }
2124
2125         _plugins[0]->set_insert_id(this->id());
2126         node.add_child_nocopy (_plugins[0]->get_state());
2127
2128         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2129                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2130                 if (ac) {
2131                         node.add_child_nocopy (ac->get_state());
2132                 }
2133         }
2134
2135         return node;
2136 }
2137
2138 void
2139 PluginInsert::set_control_ids (const XMLNode& node, int version)
2140 {
2141         const XMLNodeList& nlist = node.children();
2142         XMLNodeConstIterator iter;
2143         set<Evoral::Parameter>::const_iterator p;
2144
2145         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2146                 if ((*iter)->name() == Controllable::xml_node_name) {
2147                         XMLProperty const * prop;
2148
2149                         uint32_t p = (uint32_t)-1;
2150 #ifdef LV2_SUPPORT
2151                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
2152                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2153                                 if (lv2plugin) {
2154                                         p = lv2plugin->port_index(prop->value().c_str());
2155                                 }
2156                         }
2157 #endif
2158                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
2159                                 p = atoi (prop->value());
2160                         }
2161
2162                         if (p != (uint32_t)-1) {
2163
2164                                 /* this may create the new controllable */
2165
2166                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2167
2168 #ifndef NO_PLUGIN_STATE
2169                                 if (!c) {
2170                                         continue;
2171                                 }
2172                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2173                                 if (ac) {
2174                                         ac->set_state (**iter, version);
2175                                 }
2176 #endif
2177                         }
2178                 }
2179         }
2180 }
2181
2182 int
2183 PluginInsert::set_state(const XMLNode& node, int version)
2184 {
2185         XMLNodeList nlist = node.children();
2186         XMLNodeIterator niter;
2187         XMLPropertyList plist;
2188         XMLProperty const * prop;
2189         ARDOUR::PluginType type;
2190
2191         if ((prop = node.property ("type")) == 0) {
2192                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2193                 return -1;
2194         }
2195
2196         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2197                 type = ARDOUR::LADSPA;
2198         } else if (prop->value() == X_("lv2")) {
2199                 type = ARDOUR::LV2;
2200         } else if (prop->value() == X_("windows-vst")) {
2201                 type = ARDOUR::Windows_VST;
2202         } else if (prop->value() == X_("lxvst")) {
2203                 type = ARDOUR::LXVST;
2204         } else if (prop->value() == X_("audiounit")) {
2205                 type = ARDOUR::AudioUnit;
2206         } else if (prop->value() == X_("luaproc")) {
2207                 type = ARDOUR::Lua;
2208         } else {
2209                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2210                                   prop->value())
2211                       << endmsg;
2212                 return -1;
2213         }
2214
2215         prop = node.property ("unique-id");
2216
2217         if (prop == 0) {
2218 #ifdef WINDOWS_VST_SUPPORT
2219                 /* older sessions contain VST plugins with only an "id" field.
2220                  */
2221
2222                 if (type == ARDOUR::Windows_VST) {
2223                         prop = node.property ("id");
2224                 }
2225 #endif
2226
2227 #ifdef LXVST_SUPPORT
2228                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2229
2230                 if (type == ARDOUR::LXVST) {
2231                         prop = node.property ("id");
2232                 }
2233 #endif
2234                 /* recheck  */
2235
2236                 if (prop == 0) {
2237                         error << _("Plugin has no unique ID field") << endmsg;
2238                         return -1;
2239                 }
2240         }
2241
2242         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2243
2244         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2245          * allow to move sessions windows <> linux */
2246 #ifdef LXVST_SUPPORT
2247         if (plugin == 0 && type == ARDOUR::Windows_VST) {
2248                 type = ARDOUR::LXVST;
2249                 plugin = find_plugin (_session, prop->value(), type);
2250         }
2251 #endif
2252
2253 #ifdef WINDOWS_VST_SUPPORT
2254         if (plugin == 0 && type == ARDOUR::LXVST) {
2255                 type = ARDOUR::Windows_VST;
2256                 plugin = find_plugin (_session, prop->value(), type);
2257         }
2258 #endif
2259
2260         if (plugin == 0 && type == ARDOUR::Lua) {
2261                 /* unique ID (sha1 of script) was not found,
2262                  * load the plugin from the serialized version in the
2263                  * session-file instead.
2264                  */
2265                 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2266                 XMLNode *ls = node.child (lp->state_node_name().c_str());
2267                 if (ls && lp) {
2268                         lp->set_script_from_state (*ls);
2269                         plugin = lp;
2270                 }
2271         }
2272
2273         if (plugin == 0) {
2274                 error << string_compose(
2275                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2276                           "Perhaps it was removed or moved since it was last used."),
2277                         prop->value())
2278                       << endmsg;
2279                 return -1;
2280         }
2281
2282         // The name of the PluginInsert comes from the plugin, nothing else
2283         _name = plugin->get_info()->name;
2284
2285         uint32_t count = 1;
2286
2287         // Processor::set_state() will set this, but too late
2288         // for it to be available when setting up plugin
2289         // state. We can't call Processor::set_state() until
2290         // the plugins themselves are created and added.
2291
2292         set_id (node);
2293
2294         if (_plugins.empty()) {
2295                 /* if we are adding the first plugin, we will need to set
2296                    up automatable controls.
2297                 */
2298                 add_plugin (plugin);
2299                 create_automatable_parameters ();
2300                 set_control_ids (node, version);
2301         }
2302
2303         if ((prop = node.property ("count")) != 0) {
2304                 sscanf (prop->value().c_str(), "%u", &count);
2305         }
2306
2307         if (_plugins.size() != count) {
2308                 for (uint32_t n = 1; n < count; ++n) {
2309                         add_plugin (plugin_factory (plugin));
2310                 }
2311         }
2312
2313         Processor::set_state (node, version);
2314
2315         PBD::ID new_id = this->id();
2316         PBD::ID old_id = this->id();
2317
2318         if ((prop = node.property ("id")) != 0) {
2319                 old_id = prop->value ();
2320         }
2321
2322         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2323
2324                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2325                    and set all plugins to the same state.
2326                 */
2327
2328                 if ((*niter)->name() == plugin->state_node_name()) {
2329
2330                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2331                                 /* Plugin state can include external files which are named after the ID.
2332                                  *
2333                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
2334                                  * been changed, so we need to use the old ID from the XML to load the
2335                                  * state and then update the ID.
2336                                  *
2337                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
2338                                  * but we need to call set_insert_id() to clear the cached plugin-state
2339                                  * and force a change.
2340                                  */
2341                                 if (!regenerate_xml_or_string_ids ()) {
2342                                         (*i)->set_insert_id (new_id);
2343                                 } else {
2344                                         (*i)->set_insert_id (old_id);
2345                                 }
2346
2347                                 (*i)->set_state (**niter, version);
2348
2349                                 if (regenerate_xml_or_string_ids ()) {
2350                                         (*i)->set_insert_id (new_id);
2351                                 }
2352                         }
2353
2354                         break;
2355                 }
2356         }
2357
2358         if (version < 3000) {
2359
2360                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2361                    this is all handled by Automatable
2362                 */
2363
2364                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2365                         if ((*niter)->name() == "Redirect") {
2366                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2367                                 Processor::set_state (**niter, version);
2368                                 break;
2369                         }
2370                 }
2371
2372                 set_parameter_state_2X (node, version);
2373         }
2374
2375         if ((prop = node.property (X_("custom"))) != 0) {
2376                 _custom_cfg = string_is_affirmative (prop->value());
2377         }
2378
2379         uint32_t in_maps = 0;
2380         uint32_t out_maps = 0;
2381         XMLNodeList kids = node.children ();
2382         for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2383                 if ((*i)->name() == X_("ConfiguredInput")) {
2384                         _configured_in = ChanCount(**i);
2385                 }
2386                 if ((*i)->name() == X_("CustomSinks")) {
2387                         _custom_sinks = ChanCount(**i);
2388                 }
2389                 if ((*i)->name() == X_("ConfiguredOutput")) {
2390                         _custom_out = ChanCount(**i);
2391                         _configured_out = ChanCount(**i);
2392                 }
2393                 if ((*i)->name() == X_("PresetOutput")) {
2394                         _preset_out = ChanCount(**i);
2395                 }
2396                 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2397                         long pc = atol (&((*i)->name().c_str()[9]));
2398                         if (pc >= 0 && pc <= (long) get_count()) {
2399                                 _in_map[pc] = ChanMapping (**i);
2400                                 ++in_maps;
2401                         }
2402                 }
2403                 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2404                         long pc = atol (&((*i)->name().c_str()[10]));
2405                         if (pc >= 0 && pc <= (long) get_count()) {
2406                                 _out_map[pc] = ChanMapping (**i);
2407                                 ++out_maps;
2408                         }
2409                 }
2410                 if ((*i)->name () ==  "ThruMap") {
2411                                 _thru_map = ChanMapping (**i);
2412                 }
2413
2414                 // sidechain is a Processor (IO)
2415                 if ((*i)->name () ==  Processor::state_node_name) {
2416                         if (!_sidechain) {
2417                                 add_sidechain (0);
2418                         }
2419                         _sidechain->set_state (**i, version);
2420                 }
2421         }
2422
2423         if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2424                 _maps_from_state = true;
2425         }
2426
2427         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2428                 if (active()) {
2429                         (*i)->activate ();
2430                 } else {
2431                         (*i)->deactivate ();
2432                 }
2433         }
2434
2435         PluginConfigChanged (); /* EMIT SIGNAL */
2436         return 0;
2437 }
2438
2439 void
2440 PluginInsert::update_id (PBD::ID id)
2441 {
2442         set_id (id.to_s());
2443         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2444                 (*i)->set_insert_id (id);
2445         }
2446 }
2447
2448 void
2449 PluginInsert::set_state_dir (const std::string& d)
2450 {
2451         // state() only saves the state of the first plugin
2452         _plugins[0]->set_state_dir (d);
2453 }
2454
2455 void
2456 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2457 {
2458         XMLNodeList nlist = node.children();
2459         XMLNodeIterator niter;
2460
2461         /* look for port automation node */
2462
2463         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2464
2465                 if ((*niter)->name() != port_automation_node_name) {
2466                         continue;
2467                 }
2468
2469                 XMLNodeList cnodes;
2470                 XMLProperty const * cprop;
2471                 XMLNodeConstIterator iter;
2472                 XMLNode *child;
2473                 const char *port;
2474                 uint32_t port_id;
2475
2476                 cnodes = (*niter)->children ("port");
2477
2478                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2479
2480                         child = *iter;
2481
2482                         if ((cprop = child->property("number")) != 0) {
2483                                 port = cprop->value().c_str();
2484                         } else {
2485                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2486                                 continue;
2487                         }
2488
2489                         sscanf (port, "%" PRIu32, &port_id);
2490
2491                         if (port_id >= _plugins[0]->parameter_count()) {
2492                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2493                                 continue;
2494                         }
2495
2496                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2497                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2498
2499                         if (c && c->alist()) {
2500                                 if (!child->children().empty()) {
2501                                         c->alist()->set_state (*child->children().front(), version);
2502
2503                                         /* In some cases 2.X saves lists with min_yval and max_yval
2504                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
2505                                            in A3 because these min/max values are used to compute
2506                                            where GUI control points should be drawn.  If we see such
2507                                            values, `correct' them to the min/max of the appropriate
2508                                            parameter.
2509                                         */
2510
2511                                         float min_y = c->alist()->get_min_y ();
2512                                         float max_y = c->alist()->get_max_y ();
2513
2514                                         ParameterDescriptor desc;
2515                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
2516
2517                                         if (min_y == FLT_MIN) {
2518                                                 min_y = desc.lower;
2519                                         }
2520
2521                                         if (max_y == FLT_MAX) {
2522                                                 max_y = desc.upper;
2523                                         }
2524
2525                                         c->alist()->set_yrange (min_y, max_y);
2526                                 }
2527                         } else {
2528                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2529                         }
2530                 }
2531
2532                 /* done */
2533
2534                 break;
2535         }
2536 }
2537
2538
2539 string
2540 PluginInsert::describe_parameter (Evoral::Parameter param)
2541 {
2542         if (param.type() == PluginAutomation) {
2543                 return _plugins[0]->describe_parameter (param);
2544         } else if (param.type() == PluginPropertyAutomation) {
2545                 boost::shared_ptr<AutomationControl> c(automation_control(param));
2546                 if (c && !c->desc().label.empty()) {
2547                         return c->desc().label;
2548                 }
2549         }
2550         return Automatable::describe_parameter(param);
2551 }
2552
2553 ARDOUR::framecnt_t
2554 PluginInsert::signal_latency() const
2555 {
2556         if (_user_latency) {
2557                 return _user_latency;
2558         }
2559
2560         return _plugins[0]->signal_latency ();
2561 }
2562
2563 ARDOUR::PluginType
2564 PluginInsert::type ()
2565 {
2566        return plugin()->get_info()->type;
2567 }
2568
2569 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
2570                                             const Evoral::Parameter&          param,
2571                                             const ParameterDescriptor&        desc,
2572                                             boost::shared_ptr<AutomationList> list)
2573         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2574         , _plugin (p)
2575 {
2576         if (alist()) {
2577                 alist()->reset_default (desc.normal);
2578                 if (desc.toggled) {
2579                         list->set_interpolation(Evoral::ControlList::Discrete);
2580                 }
2581         }
2582
2583         if (desc.toggled) {
2584                 set_flags(Controllable::Toggle);
2585         }
2586 }
2587
2588 /** @param val `user' value */
2589 void
2590 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2591 {
2592         if (writable()) {
2593                 _set_value (user_val, group_override);
2594         }
2595 }
2596 void
2597 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2598 {
2599         /* used only by automation playback */
2600         _set_value (user_val, Controllable::NoGroup);
2601 }
2602
2603 void
2604 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2605 {
2606         /* FIXME: probably should be taking out some lock here.. */
2607
2608         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2609                 (*i)->set_parameter (_list->parameter().id(), user_val);
2610         }
2611
2612         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2613         if (iasp) {
2614                 iasp->set_parameter (_list->parameter().id(), user_val);
2615         }
2616
2617         AutomationControl::set_value (user_val, group_override);
2618 }
2619
2620 void
2621 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2622 {
2623         AutomationControl::set_value (user_val, Controllable::NoGroup);
2624 }
2625
2626 XMLNode&
2627 PluginInsert::PluginControl::get_state ()
2628 {
2629         stringstream ss;
2630
2631         XMLNode& node (AutomationControl::get_state());
2632         ss << parameter().id();
2633         node.add_property (X_("parameter"), ss.str());
2634 #ifdef LV2_SUPPORT
2635         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2636         if (lv2plugin) {
2637                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2638         }
2639 #endif
2640
2641         return node;
2642 }
2643
2644 /** @return `user' val */
2645 double
2646 PluginInsert::PluginControl::get_value () const
2647 {
2648         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2649
2650         if (!plugin) {
2651                 return 0.0;
2652         }
2653
2654         return plugin->get_parameter (_list->parameter().id());
2655 }
2656
2657 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
2658                                                             const Evoral::Parameter&          param,
2659                                                             const ParameterDescriptor&        desc,
2660                                                             boost::shared_ptr<AutomationList> list)
2661         : AutomationControl (p->session(), param, desc, list)
2662         , _plugin (p)
2663 {
2664         if (alist()) {
2665                 alist()->set_yrange (desc.lower, desc.upper);
2666                 alist()->reset_default (desc.normal);
2667         }
2668
2669         if (desc.toggled) {
2670                 set_flags(Controllable::Toggle);
2671         }
2672 }
2673
2674 void
2675 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2676 {
2677         if (writable()) {
2678                 set_value_unchecked (user_val);
2679         }
2680 }
2681
2682 void
2683 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2684 {
2685         /* Old numeric set_value(), coerce to appropriate datatype if possible.
2686            This is lossy, but better than nothing until Ardour's automation system
2687            can handle various datatypes all the way down. */
2688         const Variant value(_desc.datatype, user_val);
2689         if (value.type() == Variant::NOTHING) {
2690                 error << "set_value(double) called for non-numeric property" << endmsg;
2691                 return;
2692         }
2693
2694         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2695                 (*i)->set_property(_list->parameter().id(), value);
2696         }
2697
2698         _value = value;
2699         AutomationControl::set_value (user_val, Controllable::NoGroup);
2700 }
2701
2702 XMLNode&
2703 PluginInsert::PluginPropertyControl::get_state ()
2704 {
2705         stringstream ss;
2706
2707         XMLNode& node (AutomationControl::get_state());
2708         ss << parameter().id();
2709         node.add_property (X_("property"), ss.str());
2710         node.remove_property (X_("value"));
2711
2712         return node;
2713 }
2714
2715 double
2716 PluginInsert::PluginPropertyControl::get_value () const
2717 {
2718         return _value.to_double();
2719 }
2720
2721 boost::shared_ptr<Plugin>
2722 PluginInsert::get_impulse_analysis_plugin()
2723 {
2724         boost::shared_ptr<Plugin> ret;
2725         if (_impulseAnalysisPlugin.expired()) {
2726                 // LV2 in particular uses various _session params
2727                 // during init() -- most notably block_size..
2728                 // not great.
2729                 ret = plugin_factory(_plugins[0]);
2730                 ret->configure_io (internal_input_streams (), internal_output_streams ());
2731                 _impulseAnalysisPlugin = ret;
2732         } else {
2733                 ret = _impulseAnalysisPlugin.lock();
2734         }
2735
2736         return ret;
2737 }
2738
2739 void
2740 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2741 {
2742         // called from outside the audio thread, so this should be safe
2743         // only do audio as analysis is (currently) only for audio plugins
2744         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, internal_input_streams().n_audio(),  nframes);
2745         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2746
2747         _signal_analysis_collected_nframes   = 0;
2748         _signal_analysis_collect_nframes_max = nframes;
2749 }
2750
2751 /** Add a plugin to our list */
2752 void
2753 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2754 {
2755         plugin->set_insert_id (this->id());
2756
2757         if (_plugins.empty()) {
2758                 /* first (and probably only) plugin instance - connect to relevant signals */
2759
2760                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2761                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2762                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2763                 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2764                 _custom_sinks = plugin->get_info()->n_inputs;
2765                 // cache sidechain port count
2766                 _cached_sidechain_pins.reset ();
2767                 const ChanCount& nis (plugin->get_info()->n_inputs);
2768                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2769                         for (uint32_t in = 0; in < nis.get (*t); ++in) {
2770                                 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2771                                 if (iod.is_sidechain) {
2772                                         _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2773                                 }
2774                         }
2775                 }
2776         }
2777 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2778         boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2779         if (vst) {
2780                 vst->set_insert (this, _plugins.size ());
2781         }
2782 #endif
2783         _plugins.push_back (plugin);
2784 }
2785
2786 bool
2787 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
2788 {
2789         bool ok = true;
2790         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2791                 if (! (*i)->load_preset (pr)) {
2792                         ok = false;
2793                 }
2794         }
2795         return ok;
2796 }
2797
2798 void
2799 PluginInsert::realtime_handle_transport_stopped ()
2800 {
2801         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2802                 (*i)->realtime_handle_transport_stopped ();
2803         }
2804 }
2805
2806 void
2807 PluginInsert::realtime_locate ()
2808 {
2809         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2810                 (*i)->realtime_locate ();
2811         }
2812 }
2813
2814 void
2815 PluginInsert::monitoring_changed ()
2816 {
2817         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2818                 (*i)->monitoring_changed ();
2819         }
2820 }
2821
2822 void
2823 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2824 {
2825         // this is called in RT context, LatencyChanged is emitted after run()
2826         _latency_changed = true;
2827 }
2828
2829 void
2830 PluginInsert::start_touch (uint32_t param_id)
2831 {
2832         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2833         if (ac) {
2834                 ac->start_touch (session().audible_frame());
2835         }
2836 }
2837
2838 void
2839 PluginInsert::end_touch (uint32_t param_id)
2840 {
2841         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2842         if (ac) {
2843                 ac->stop_touch (true, session().audible_frame());
2844         }
2845 }
2846
2847 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2848 {
2849         switch (m.method) {
2850                 case PluginInsert::Impossible: o << "Impossible"; break;
2851                 case PluginInsert::Delegate:   o << "Delegate"; break;
2852                 case PluginInsert::NoInputs:   o << "NoInputs"; break;
2853                 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2854                 case PluginInsert::Replicate:  o << "Replicate"; break;
2855                 case PluginInsert::Split:      o << "Split"; break;
2856                 case PluginInsert::Hide:       o << "Hide"; break;
2857         }
2858         o << " cnt: " << m.plugins
2859                 << (m.strict_io ? " strict-io" : "")
2860                 << (m.custom_cfg ? " custom-cfg" : "");
2861         if (m.method == PluginInsert::Hide) {
2862                 o << " hide: " << m.hide;
2863         }
2864         o << "\n";
2865         return o;
2866 }