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