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