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