libs/ardour/plugin_insert.cc

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