libs/ardour/plugin_insert.cc

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