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