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