libs/ardour/plugin_insert.cc

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