libs/ardour/plugin_insert.cc

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