libs/ardour/plugin_insert.cc

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