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, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
 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 (now, 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, 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, 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, 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)
 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), in_map, out_map, nframes, 0);
 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), in_map, out_map, nframes, 0);
 985         }
 986 }
 987
 988 void
 989 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, 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, nframes, true);
 998                 }
 999
1000                 if (_session.transport_rolling() || _session.bounce_processing()) {
1001                         automation_run (bufs, start_frame, nframes);
1002                 } else {
1003                         connect_and_run (bufs, 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, pframes_t nframes)
1020 {
1021         Evoral::ControlEvent next_event (0, 0.0f);
1022         framepos_t now = start;
1023         framepos_t end = now + nframes;
1024         framecnt_t offset = 0;
1025
1026         Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1027
1028         if (!lm.locked()) {
1029                 connect_and_run (bufs, nframes, offset, false);
1030                 return;
1031         }
1032
1033         if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1034
1035                 /* no events have a time within the relevant range */
1036
1037                 connect_and_run (bufs, nframes, offset, true, now);
1038                 return;
1039         }
1040
1041         while (nframes) {
1042
1043                 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
1044
1045                 connect_and_run (bufs, cnt, offset, true, now);
1046
1047                 nframes -= cnt;
1048                 offset += cnt;
1049                 now += cnt;
1050
1051                 if (!find_next_event (now, end, next_event)) {
1052                         break;
1053                 }
1054         }
1055
1056         /* cleanup anything that is left to do */
1057
1058         if (nframes) {
1059                 connect_and_run (bufs, nframes, offset, true, now);
1060         }
1061 }
1062
1063 float
1064 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1065 {
1066         if (param.type() != PluginAutomation)
1067                 return 1.0;
1068
1069         if (_plugins.empty()) {
1070                 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1071                       << endmsg;
1072                 abort(); /*NOTREACHED*/
1073         }
1074
1075         return _plugins[0]->default_value (param.id());
1076 }
1077
1078
1079 bool
1080 PluginInsert::can_reset_all_parameters ()
1081 {
1082         bool all = true;
1083         uint32_t params = 0;
1084         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1085                 bool ok=false;
1086                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1087
1088                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1089                         continue;
1090                 }
1091
1092                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1093                 if (!ac) {
1094                         continue;
1095                 }
1096
1097                 ++params;
1098                 if (ac->automation_state() & Play) {
1099                         all = false;
1100                         break;
1101                 }
1102         }
1103         return all && (params > 0);
1104 }
1105
1106 bool
1107 PluginInsert::reset_parameters_to_default ()
1108 {
1109         bool all = true;
1110
1111         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1112                 bool ok=false;
1113                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1114
1115                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1116                         continue;
1117                 }
1118
1119                 const float dflt = _plugins[0]->default_value (cid);
1120                 const float curr = _plugins[0]->get_parameter (cid);
1121
1122                 if (dflt == curr) {
1123                         continue;
1124                 }
1125
1126                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1127                 if (!ac) {
1128                         continue;
1129                 }
1130
1131                 if (ac->automation_state() & Play) {
1132                         all = false;
1133                         continue;
1134                 }
1135
1136                 ac->set_value (dflt, Controllable::NoGroup);
1137         }
1138         return all;
1139 }
1140
1141 boost::shared_ptr<Plugin>
1142 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1143 {
1144         boost::shared_ptr<LadspaPlugin> lp;
1145         boost::shared_ptr<LuaProc> lua;
1146 #ifdef LV2_SUPPORT
1147         boost::shared_ptr<LV2Plugin> lv2p;
1148 #endif
1149 #ifdef WINDOWS_VST_SUPPORT
1150         boost::shared_ptr<WindowsVSTPlugin> vp;
1151 #endif
1152 #ifdef LXVST_SUPPORT
1153         boost::shared_ptr<LXVSTPlugin> lxvp;
1154 #endif
1155 #ifdef AUDIOUNIT_SUPPORT
1156         boost::shared_ptr<AUPlugin> ap;
1157 #endif
1158
1159         if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1160                 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1161         } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1162                 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1163 #ifdef LV2_SUPPORT
1164         } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1165                 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1166 #endif
1167 #ifdef WINDOWS_VST_SUPPORT
1168         } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1169                 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1170 #endif
1171 #ifdef LXVST_SUPPORT
1172         } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1173                 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1174 #endif
1175 #ifdef AUDIOUNIT_SUPPORT
1176         } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1177                 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1178 #endif
1179         }
1180
1181         fatal << string_compose (_("programming error: %1"),
1182                           X_("unknown plugin type in PluginInsert::plugin_factory"))
1183               << endmsg;
1184         abort(); /*NOTREACHED*/
1185         return boost::shared_ptr<Plugin> ((Plugin*) 0);
1186 }
1187
1188 void
1189 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1190         if (num < _in_map.size()) {
1191                 bool changed = _in_map[num] != m;
1192                 _in_map[num] = m;
1193                 changed |= sanitize_maps ();
1194                 if (changed) {
1195                         PluginMapChanged (); /* EMIT SIGNAL */
1196                         _mapping_changed = true;
1197                         _session.set_dirty();
1198                 }
1199         }
1200 }
1201
1202 void
1203 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1204         if (num < _out_map.size()) {
1205                 bool changed = _out_map[num] != m;
1206                 _out_map[num] = m;
1207                 changed |= sanitize_maps ();
1208                 if (changed) {
1209                         PluginMapChanged (); /* EMIT SIGNAL */
1210                         _mapping_changed = true;
1211                         _session.set_dirty();
1212                 }
1213         }
1214 }
1215
1216 void
1217 PluginInsert::set_thru_map (ChanMapping m) {
1218         bool changed = _thru_map != m;
1219         _thru_map = m;
1220         changed |= sanitize_maps ();
1221         if (changed) {
1222                 PluginMapChanged (); /* EMIT SIGNAL */
1223                 _mapping_changed = true;
1224                 _session.set_dirty();
1225         }
1226 }
1227
1228 bool
1229 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1230                 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1231 {
1232         if (_configured) { return false; }
1233         _configured_in = in;
1234         _configured_out = out;
1235         _in_map[0] = im;
1236         _out_map[0] = om;
1237         _thru_map = tm;
1238         _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1239         return true;
1240 }
1241
1242 ChanMapping
1243 PluginInsert::input_map () const
1244 {
1245         ChanMapping rv;
1246         uint32_t pc = 0;
1247         for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1248                 ChanMapping m (i->second);
1249                 const ChanMapping::Mappings& mp ((*i).second.mappings());
1250                 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1251                         for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1252                                 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1253                         }
1254                 }
1255         }
1256         return rv;
1257 }
1258
1259 ChanMapping
1260 PluginInsert::output_map () const
1261 {
1262         ChanMapping rv;
1263         uint32_t pc = 0;
1264         for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1265                 ChanMapping m (i->second);
1266                 const ChanMapping::Mappings& mp ((*i).second.mappings());
1267                 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1268                         for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1269                                 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1270                         }
1271                 }
1272         }
1273         if (has_midi_bypass ()) {
1274                 rv.set (DataType::MIDI, 0, 0);
1275         }
1276
1277         return rv;
1278 }
1279
1280 bool
1281 PluginInsert::has_midi_bypass () const
1282 {
1283         if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1284                         && natural_output_streams ().n_midi () == 0) {
1285                 return true;
1286         }
1287         return false;
1288 }
1289
1290 bool
1291 PluginInsert::has_midi_thru () const
1292 {
1293         if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1294                         && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1295                 return true;
1296         }
1297         return false;
1298 }
1299
1300 #ifdef MIXBUS
1301 bool
1302 PluginInsert::is_channelstrip () const {
1303         return _plugins.front()->is_channelstrip();
1304 }
1305 #endif
1306
1307 bool
1308 PluginInsert::check_inplace ()
1309 {
1310         bool inplace_ok = !_plugins.front()->inplace_broken ();
1311
1312         if (_thru_map.n_total () > 0) {
1313                 // TODO once midi-bypass is part of the mapping, ignore it
1314                 inplace_ok = false;
1315         }
1316
1317         if (_match.method == Split && inplace_ok) {
1318                 assert (get_count() == 1);
1319                 assert (_in_map.size () == 1);
1320                 if (!_out_map[0].is_monotonic ()) {
1321                         inplace_ok = false;
1322                 }
1323                 if (_configured_internal != _configured_in) {
1324                         /* no sidechain -- TODO we could allow this with
1325                          * some more logic in PluginInsert::connect_and_run().
1326                          *
1327                          * PluginInsert::reset_map() already maps it.
1328                          */
1329                         inplace_ok = false;
1330                 }
1331                 /* check mapping */
1332                 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1333                         if (_configured_internal.get (*t) == 0) {
1334                                 continue;
1335                         }
1336                         bool valid;
1337                         uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1338                         if (!valid || first_idx != 0) {
1339                                 // so far only allow to copy the *first* stream's buffer to others
1340                                 inplace_ok = false;
1341                         } else {
1342                                 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1343                                         uint32_t idx = _in_map[0].get (*t, i, &valid);
1344                                         if (valid && idx != first_idx) {
1345                                                 inplace_ok = false;
1346                                                 break;
1347                                         }
1348                                 }
1349                         }
1350                 }
1351
1352                 if (inplace_ok) {
1353                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1354                         return false;
1355                 }
1356         }
1357
1358         for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1359                 if (!_in_map[pc].is_monotonic ()) {
1360                         inplace_ok = false;
1361                 }
1362                 if (!_out_map[pc].is_monotonic ()) {
1363                         inplace_ok = false;
1364                 }
1365         }
1366
1367         if (inplace_ok) {
1368                 /* check if every output is fed by the corresponding input
1369                  *
1370                  * this prevents  in-port 1 -> sink-pin 2  ||  source-pin 1 -> out port 1, source-pin 2 -> out port 2
1371                  * (with in-place,  source-pin 1 -> out port 1 overwrites in-port 1)
1372                  *
1373                  * but allows     in-port 1 -> sink-pin 2  ||  source-pin 2 -> out port 1
1374                  */
1375                 ChanMapping in_map (input_map ());
1376                 const ChanMapping::Mappings out_m (output_map ().mappings ());
1377                 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1378                         for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1379                                 /* src-pin: c->first, out-port: c->second */
1380                                 bool valid;
1381                                 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1382                                 if (valid && in_port != c->second) {
1383                                         inplace_ok = false;
1384                                         break;
1385                                 }
1386                         }
1387                 }
1388         }
1389
1390         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1391         return !inplace_ok; // no-inplace
1392 }
1393
1394 bool
1395 PluginInsert::sanitize_maps ()
1396 {
1397         bool changed = false;
1398         /* strip dead wood */
1399         PinMappings new_ins;
1400         PinMappings new_outs;
1401         ChanMapping new_thru;
1402
1403         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1404                 ChanMapping new_in;
1405                 ChanMapping new_out;
1406                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1407                         for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1408                                 bool valid;
1409                                 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1410                                 if (valid && idx < _configured_internal.get (*t)) {
1411                                         new_in.set (*t, i, idx);
1412                                 }
1413                         }
1414                         for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1415                                 bool valid;
1416                                 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1417                                 if (valid && idx < _configured_out.get (*t)) {
1418                                         new_out.set (*t, o, idx);
1419                                 }
1420                         }
1421                 }
1422                 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1423                         changed = true;
1424                 }
1425                 new_ins[pc] = new_in;
1426                 new_outs[pc] = new_out;
1427         }
1428
1429         /* prevent dup output assignments */
1430         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1431                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1432                         bool mapped = false;
1433                         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1434                                 bool valid;
1435                                 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1436                                 if (valid && mapped) {
1437                                         new_outs[pc].unset (*t, idx);
1438                                 } else if (valid) {
1439                                         mapped = true;
1440                                 }
1441                         }
1442                 }
1443         }
1444
1445         /* remove excess thru */
1446         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1447                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1448                         bool valid;
1449                         uint32_t idx = _thru_map.get (*t, o, &valid);
1450                         if (valid && idx < _configured_internal.get (*t)) {
1451                                 new_thru.set (*t, o, idx);
1452                         }
1453                 }
1454         }
1455
1456         /* prevent out + thru,  existing plugin outputs override thru */
1457         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1458                 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1459                         bool mapped = false;
1460                         bool valid;
1461                         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1462                                 new_outs[pc].get_src (*t, o, &mapped);
1463                                 if (mapped) { break; }
1464                         }
1465                         if (!mapped) { continue; }
1466                         uint32_t idx = new_thru.get (*t, o, &valid);
1467                         if (mapped) {
1468                                 new_thru.unset (*t, idx);
1469                         }
1470                 }
1471         }
1472
1473         if (has_midi_bypass ()) {
1474                 // TODO: include midi-bypass in the thru set,
1475                 // remove dedicated handling.
1476                 new_thru.unset (DataType::MIDI, 0);
1477         }
1478
1479         if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1480                 changed = true;
1481         }
1482         _in_map = new_ins;
1483         _out_map = new_outs;
1484         _thru_map = new_thru;
1485
1486         return changed;
1487 }
1488
1489 bool
1490 PluginInsert::reset_map (bool emit)
1491 {
1492         const PinMappings old_in (_in_map);
1493         const PinMappings old_out (_out_map);
1494
1495         _in_map.clear ();
1496         _out_map.clear ();
1497         _thru_map = ChanMapping ();
1498
1499         /* build input map */
1500         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1501                 uint32_t sc = 0; // side-chain round-robin (all instances)
1502                 uint32_t pc = 0;
1503                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1504                         const uint32_t nis = natural_input_streams ().get(*t);
1505                         const uint32_t stride = nis - sidechain_input_pins().get (*t);
1506
1507                         /* SC inputs are last in the plugin-insert.. */
1508                         const uint32_t sc_start = _configured_in.get (*t);
1509                         const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1510                         /* ...but may not be at the end of the plugin ports.
1511                          * in case the side-chain is not the last port, shift connections back.
1512                          * and connect to side-chain
1513                          */
1514                         uint32_t shift = 0;
1515                         uint32_t ic = 0; // split inputs
1516                         const uint32_t cend = _configured_in.get (*t);
1517
1518                         for (uint32_t in = 0; in < nis; ++in) {
1519                                 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1520                                 if (iod.is_sidechain) {
1521                                         /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1522                                         if (sc_len > 0) {// side-chain may be hidden
1523                                                 _in_map[pc].set (*t, in, sc_start + sc);
1524                                                 sc = (sc + 1) % sc_len;
1525                                         }
1526                                         ++shift;
1527                                 } else {
1528                                         if (_match.method == Split) {
1529                                                 if (cend == 0) { continue; }
1530                                                 if (_strict_io && ic + stride * pc >= cend) {
1531                                                         break;
1532                                                 }
1533                                                 /* connect *no* sidechain sinks in round-robin fashion */
1534                                                 _in_map[pc].set (*t, in, ic + stride * pc);
1535                                                 if (_strict_io && (ic + 1) == cend) {
1536                                                         break;
1537                                                 }
1538                                                 ic = (ic + 1) % cend;
1539                                         } else {
1540                                                 uint32_t s = in - shift;
1541                                                 if (stride * pc + s < cend) {
1542                                                         _in_map[pc].set (*t, in, s + stride * pc);
1543                                                 }
1544                                         }
1545                                 }
1546                         }
1547                 }
1548         }
1549
1550         /* build output map */
1551         uint32_t pc = 0;
1552         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1553                 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1554                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1555                         _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1556                 }
1557         }
1558
1559         sanitize_maps ();
1560         if (old_in == _in_map && old_out == _out_map) {
1561                 return false;
1562         }
1563         if (emit) {
1564                 PluginMapChanged (); /* EMIT SIGNAL */
1565                 _mapping_changed = true;
1566                 _session.set_dirty();
1567         }
1568         return true;
1569 }
1570
1571 bool
1572 PluginInsert::configure_io (ChanCount in, ChanCount out)
1573 {
1574         Match old_match = _match;
1575         ChanCount old_in;
1576         ChanCount old_internal;
1577         ChanCount old_out;
1578         ChanCount old_pins;
1579
1580         old_pins = natural_input_streams();
1581         old_in = _configured_in;
1582         old_out = _configured_out;
1583         old_internal = _configured_internal;
1584
1585         _configured_in = in;
1586         _configured_internal = in;
1587         _configured_out = out;
1588
1589         if (_sidechain) {
1590                 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1591                  * (currently _sidechain->configure_io always succeeds
1592                  *  since Processor::configure_io() succeeds)
1593                  */
1594                 if (!_sidechain->configure_io (in, out)) {
1595                         DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1596                         return false;
1597                 }
1598                 _configured_internal += _sidechain->input()->n_ports();
1599
1600                 // include (static_cast<Route*>owner())->name() ??
1601                 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1602         }
1603
1604         /* get plugin configuration */
1605         _match = private_can_support_io_configuration (in, out);
1606 #ifndef NDEBUG
1607         if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1608                 DEBUG_STR_DECL(a);
1609                 DEBUG_STR_APPEND(a, string_compose ("%1: ",  name()));
1610                 DEBUG_STR_APPEND(a, _match);
1611                 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1612         }
1613 #endif
1614
1615         /* set the matching method and number of plugins that we will use to meet this configuration */
1616         if (set_count (_match.plugins) == false) {
1617                 PluginIoReConfigure (); /* EMIT SIGNAL */
1618                 _configured = false;
1619                 return false;
1620         }
1621
1622         /* configure plugins */
1623         switch (_match.method) {
1624         case Split:
1625         case Hide:
1626                 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1627                         PluginIoReConfigure (); /* EMIT SIGNAL */
1628                         _configured = false;
1629                         return false;
1630                 }
1631                 break;
1632         case Delegate:
1633                 {
1634                         ChanCount din (_configured_internal);
1635                         ChanCount dout (din); // hint
1636                         if (_custom_cfg) {
1637                                 if (_custom_sinks.n_total () > 0) {
1638                                         din = _custom_sinks;
1639                                 }
1640                                 dout = _custom_out;
1641                         } else if (_preset_out.n_audio () > 0) {
1642                                 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1643                         } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1644                                 dout.set (DataType::AUDIO, 2);
1645                         }
1646                         if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1647                         ChanCount useins;
1648                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1649                         bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1650                         assert (r);
1651                         if (useins.n_audio() == 0) {
1652                                 useins = din;
1653                         }
1654                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1655
1656                         if (_plugins.front()->configure_io (useins, dout) == false) {
1657                                 PluginIoReConfigure (); /* EMIT SIGNAL */
1658                                 _configured = false;
1659                                 return false;
1660                         }
1661                         if (!_custom_cfg) {
1662                                 _custom_sinks = din;
1663                         }
1664                 }
1665                 break;
1666         default:
1667                 if (_plugins.front()->configure_io (in, out) == false) {
1668                         PluginIoReConfigure (); /* EMIT SIGNAL */
1669                         _configured = false;
1670                         return false;
1671                 }
1672                 break;
1673         }
1674
1675         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",
1676                                 name (),
1677                                 _configured ? "Y" : "N",
1678                                 _maps_from_state ? "Y" : "N",
1679                                 old_in == in ? "==" : "!=",
1680                                 old_out == out ? "==" : "!=",
1681                                 old_pins == natural_input_streams () ? "==" : "!=",
1682                                 old_match.method == _match.method ? "==" : "!=",
1683                                 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1684                                 _in_map.size() == get_count () ? "==" : "!=",
1685                                 _out_map.size() == get_count () ? "==" : "!="
1686                                 ));
1687
1688         bool mapping_changed = false;
1689         if (old_in == in && old_out == out
1690                         && _configured
1691                         && old_pins == natural_input_streams ()
1692                         && old_match.method == _match.method
1693                         && old_match.custom_cfg == _match.custom_cfg
1694                         && _in_map.size() == _out_map.size()
1695                         && _in_map.size() == get_count ()
1696                  ) {
1697                 assert (_maps_from_state == false);
1698                 /* If the configuration has not changed, keep the mapping */
1699                 mapping_changed = sanitize_maps ();
1700         } else if (_match.custom_cfg && _configured) {
1701                 assert (_maps_from_state == false);
1702                 /* don't touch the map in manual mode */
1703                 mapping_changed = sanitize_maps ();
1704         } else {
1705 #ifdef MIXBUS
1706                 if (is_channelstrip ()) {
1707                         /* fake channel map - for wire display */
1708                         _in_map.clear ();
1709                         _out_map.clear ();
1710                         _thru_map = ChanMapping ();
1711                         _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1712                         _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1713                         /* set "thru" map for in-place forward of audio */
1714                         for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1715                                 _thru_map.set (DataType::AUDIO, i, i);
1716                         }
1717                         /* and midi (after implicit 1st channel bypass) */
1718                         for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1719                                 _thru_map.set (DataType::MIDI, i, i);
1720                         }
1721                 } else
1722 #endif
1723                 if (_maps_from_state && old_in == in && old_out == out) {
1724                         mapping_changed = true;
1725                         sanitize_maps ();
1726                 } else {
1727                         /* generate a new mapping */
1728                         mapping_changed = reset_map (false);
1729                 }
1730                 _maps_from_state = false;
1731         }
1732
1733         if (mapping_changed) {
1734                 PluginMapChanged (); /* EMIT SIGNAL */
1735
1736 #ifndef NDEBUG
1737                 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1738                         uint32_t pc = 0;
1739                         DEBUG_STR_DECL(a);
1740                         DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1741                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1742                                 if (pc > 0) {
1743                         DEBUG_STR_APPEND(a, "----><----\n");
1744                                 }
1745                                 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1746                                 DEBUG_STR_APPEND(a, " * Inputs:\n");
1747                                 DEBUG_STR_APPEND(a, _in_map[pc]);
1748                                 DEBUG_STR_APPEND(a, " * Outputs:\n");
1749                                 DEBUG_STR_APPEND(a, _out_map[pc]);
1750                         }
1751                         DEBUG_STR_APPEND(a, " * Thru:\n");
1752                         DEBUG_STR_APPEND(a, _thru_map);
1753                         DEBUG_STR_APPEND(a, "-------->>--------\n");
1754                         DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1755                 }
1756 #endif
1757         }
1758
1759         _no_inplace = check_inplace ();
1760         _mapping_changed = false;
1761
1762         /* only the "noinplace_buffers" thread buffers need to be this large,
1763          * this can be optimized. other buffers are fine with
1764          * ChanCount::max (natural_input_streams (), natural_output_streams())
1765          * and route.cc's max (configured_in, configured_out)
1766          *
1767          * no-inplace copies "thru" outputs (to emulate in-place) for
1768          * all outputs (to prevent overwrite) into a temporary space
1769          * which also holds input buffers (in case the plugin does process
1770          * in-place and overwrites those).
1771          *
1772          * this buffers need to be at least as
1773          *   natural_input_streams () + possible outputs.
1774          *
1775          * sidechain inputs add a constraint on the input:
1776          * configured input + sidechain (=_configured_internal)
1777          *
1778          * NB. this also satisfies
1779          * max (natural_input_streams(), natural_output_streams())
1780          * which is needed for silence runs
1781          */
1782         _required_buffers = ChanCount::max (_configured_internal,
1783                         natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1784
1785         if (old_in != in || old_out != out || old_internal != _configured_internal
1786                         || old_pins != natural_input_streams ()
1787                         || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1788                  ) {
1789                 PluginIoReConfigure (); /* EMIT SIGNAL */
1790         }
1791
1792         _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1793         _latency_changed = true;
1794
1795         // we don't know the analysis window size, so we must work with the
1796         // current buffer size here. each request for data fills in these
1797         // buffers and the analyser makes sure it gets enough data for the
1798         // analysis window
1799         session().ensure_buffer_set (_signal_analysis_inputs, in);
1800         _signal_analysis_inputs.set_count (in);
1801
1802         session().ensure_buffer_set (_signal_analysis_outputs, out);
1803         _signal_analysis_outputs.set_count (out);
1804
1805         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1806
1807         _configured = true;
1808         return Processor::configure_io (in, out);
1809 }
1810
1811 /** Decide whether this PluginInsert can support a given IO configuration.
1812  *  To do this, we run through a set of possible solutions in rough order of
1813  *  preference.
1814  *
1815  *  @param in Required input channel count.
1816  *  @param out Filled in with the output channel count if we return true.
1817  *  @return true if the given IO configuration can be supported.
1818  */
1819 bool
1820 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1821 {
1822         if (_sidechain) {
1823                 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1824         }
1825         return private_can_support_io_configuration (in, out).method != Impossible;
1826 }
1827
1828 PluginInsert::Match
1829 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1830 {
1831         if (!_custom_cfg && _preset_out.n_audio () > 0) {
1832                 // preseed hint (for variable i/o)
1833                 out.set (DataType::AUDIO, _preset_out.n_audio ());
1834         }
1835
1836         Match rv = internal_can_support_io_configuration (in, out);
1837
1838         if (!_custom_cfg && _preset_out.n_audio () > 0) {
1839                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
1840                 out.set (DataType::AUDIO, _preset_out.n_audio ());
1841         }
1842         return rv;
1843 }
1844
1845 /** A private version of can_support_io_configuration which returns the method
1846  *  by which the configuration can be matched, rather than just whether or not
1847  *  it can be.
1848  */
1849 PluginInsert::Match
1850 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1851 {
1852         if (_plugins.empty()) {
1853                 return Match();
1854         }
1855
1856 #ifdef MIXBUS
1857         if (is_channelstrip ()) {
1858                 out = inx;
1859                 return Match (ExactMatch, 1);
1860         }
1861 #endif
1862
1863         /* if a user specified a custom cfg, so be it. */
1864         if (_custom_cfg) {
1865                 PluginInfoPtr info = _plugins.front()->get_info();
1866                 out = _custom_out;
1867                 if (info->reconfigurable_io()) {
1868                         return Match (Delegate, 1, _strict_io, true);
1869                 } else {
1870                         return Match (ExactMatch, get_count(), _strict_io, true);
1871                 }
1872         }
1873
1874         /* try automatic configuration */
1875         Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1876
1877         PluginInfoPtr info = _plugins.front()->get_info();
1878         ChanCount inputs  = info->n_inputs;
1879         ChanCount outputs = info->n_outputs;
1880
1881         /* handle case strict-i/o */
1882         if (_strict_io && m.method != Impossible) {
1883                 m.strict_io = true;
1884
1885                 /* special case MIDI instruments */
1886                 if (needs_midi_input ()) {
1887                         // output = midi-bypass + at most master-out channels.
1888                         ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1889                         max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1890                         out = ChanCount::min (out, max_out);
1891                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
1892                         return m;
1893                 }
1894
1895                 switch (m.method) {
1896                         case NoInputs:
1897                                 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1898                                         /* replicate processor to match output count (generators and such)
1899                                          * at least enough to feed every output port. */
1900                                         uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1901                                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1902                                                 uint32_t nout = outputs.get (*t);
1903                                                 if (nout == 0 || inx.get(*t) == 0) { continue; }
1904                                                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1905                                         }
1906                                         out = inx;
1907                                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
1908                                         return Match (Replicate, f, _strict_io);
1909                                 }
1910                                 break;
1911                         default:
1912                                 break;
1913                 }
1914
1915                 out = inx;
1916                 return m;
1917         }
1918
1919         if (m.method != Impossible) {
1920                 return m;
1921         }
1922
1923         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1924
1925         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
1926
1927         if (info->reconfigurable_io()) {
1928                 ChanCount useins;
1929                 out = inx; // hint
1930                 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1931                 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1932                 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
1933                 if (!r) {
1934                         // houston, we have a problem.
1935                         return Match (Impossible, 0);
1936                 }
1937                 // midi bypass
1938                 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
1939                 return Match (Delegate, 1, _strict_io);
1940         }
1941
1942         ChanCount midi_bypass;
1943         if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1944                 midi_bypass.set (DataType::MIDI, 1);
1945         }
1946
1947         // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1948         uint32_t f = 0;
1949         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1950                 uint32_t nin = ns_inputs.get (*t);
1951                 uint32_t nout = outputs.get (*t);
1952                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1953                 // prefer floor() so the count won't overly increase IFF (nin < nout)
1954                 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1955         }
1956         if (f > 0 && outputs * f >= _configured_out) {
1957                 out = outputs * f + midi_bypass;
1958                 return Match (Replicate, f, _strict_io);
1959         }
1960
1961         // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1962         f = 0;
1963         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1964                 uint32_t nin = ns_inputs.get (*t);
1965                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1966                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1967         }
1968         if (f > 0) {
1969                 out = outputs * f + midi_bypass;
1970                 return Match (Replicate, f, _strict_io);
1971         }
1972
1973         // add at least as many plugins needed to connect all inputs
1974         f = 1;
1975         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1976                 uint32_t nin = inputs.get (*t);
1977                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1978                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1979         }
1980         out = outputs * f + midi_bypass;
1981         return Match (Replicate, f, _strict_io);
1982 }
1983
1984 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1985 PluginInsert::Match
1986 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1987 {
1988         if (_plugins.empty()) {
1989                 return Match();
1990         }
1991
1992         PluginInfoPtr info = _plugins.front()->get_info();
1993         ChanCount in; in += inx;
1994         ChanCount midi_bypass;
1995
1996         if (info->reconfigurable_io()) {
1997                 /* Plugin has flexible I/O, so delegate to it
1998                  * pre-seed outputs, plugin tries closest match
1999                  */
2000                 out = in; // hint
2001                 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2002                 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2003                 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
2004                 if (!r) {
2005                         return Match (Impossible, 0);
2006                 }
2007                 // midi bypass
2008                 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2009                 return Match (Delegate, 1);
2010         }
2011
2012         ChanCount inputs  = info->n_inputs;
2013         ChanCount outputs = info->n_outputs;
2014         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
2015
2016         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2017                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
2018                 midi_bypass.set (DataType::MIDI, 1);
2019         }
2020         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
2021                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
2022                 in.set(DataType::MIDI, 0);
2023         }
2024
2025         // add internally provided sidechain ports
2026         ChanCount insc = in + sidechain_input_ports ();
2027
2028         bool no_inputs = true;
2029         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2030                 if (inputs.get (*t) != 0) {
2031                         no_inputs = false;
2032                         break;
2033                 }
2034         }
2035
2036         if (no_inputs) {
2037                 /* no inputs so we can take any input configuration since we throw it away */
2038                 out = outputs + midi_bypass;
2039                 return Match (NoInputs, 1);
2040         }
2041
2042         /* Plugin inputs match requested inputs + side-chain-ports exactly */
2043         if (inputs == insc) {
2044                 out = outputs + midi_bypass;
2045                 return Match (ExactMatch, 1);
2046         }
2047
2048         /* Plugin inputs matches without side-chain-pins */
2049         if (ns_inputs == in) {
2050                 out = outputs + midi_bypass;
2051                 return Match (ExactMatch, 1);
2052         }
2053
2054         /* We may be able to run more than one copy of the plugin within this insert
2055            to cope with the insert having more inputs than the plugin.
2056            We allow replication only for plugins with either zero or 1 inputs and outputs
2057            for every valid data type.
2058         */
2059
2060         uint32_t f             = 0;
2061         bool     can_replicate = true;
2062         for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
2063
2064                 // ignore side-chains
2065                 uint32_t nin = ns_inputs.get (*t);
2066
2067                 // No inputs of this type
2068                 if (nin == 0 && in.get(*t) == 0) {
2069                         continue;
2070                 }
2071
2072                 if (nin != 1 || outputs.get (*t) != 1) {
2073                         can_replicate = false;
2074                         break;
2075                 }
2076
2077                 // Potential factor not set yet
2078                 if (f == 0) {
2079                         f = in.get(*t) / nin;
2080                 }
2081
2082                 // Factor for this type does not match another type, can not replicate
2083                 if (f != (in.get(*t) / nin)) {
2084                         can_replicate = false;
2085                         break;
2086                 }
2087         }
2088
2089         if (can_replicate && f > 0) {
2090                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2091                         out.set (*t, outputs.get(*t) * f);
2092                 }
2093                 out += midi_bypass;
2094                 return Match (Replicate, f);
2095         }
2096
2097         /* If the processor has exactly one input of a given type, and
2098            the plugin has more, we can feed the single processor input
2099            to some or all of the plugin inputs.  This is rather
2100            special-case-y, but the 1-to-many case is by far the
2101            simplest.  How do I split thy 2 processor inputs to 3
2102            plugin inputs?  Let me count the ways ...
2103         */
2104
2105         bool can_split = true;
2106         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2107
2108                 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2109                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2110
2111                 if (!can_split_type && !nothing_to_do_for_type) {
2112                         can_split = false;
2113                 }
2114         }
2115
2116         if (can_split) {
2117                 out = outputs + midi_bypass;
2118                 return Match (Split, 1);
2119         }
2120
2121         /* If the plugin has more inputs than we want, we can `hide' some of them
2122            by feeding them silence.
2123         */
2124
2125         bool could_hide = false;
2126         bool cannot_hide = false;
2127         ChanCount hide_channels;
2128
2129         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2130                 if (inputs.get(*t) > in.get(*t)) {
2131                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2132                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2133                         could_hide = true;
2134                 } else if (inputs.get(*t) < in.get(*t)) {
2135                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2136                         cannot_hide = true;
2137                 }
2138         }
2139
2140         if (could_hide && !cannot_hide) {
2141                 out = outputs + midi_bypass;
2142                 return Match (Hide, 1, false, false, hide_channels);
2143         }
2144
2145         return Match (Impossible, 0);
2146 }
2147
2148
2149 XMLNode&
2150 PluginInsert::get_state ()
2151 {
2152         return state (true);
2153 }
2154
2155 XMLNode&
2156 PluginInsert::state (bool full)
2157 {
2158         XMLNode& node = Processor::state (full);
2159
2160         node.add_property("type", _plugins[0]->state_node_name());
2161         node.add_property("unique-id", _plugins[0]->unique_id());
2162         node.add_property("count", string_compose("%1", _plugins.size()));
2163
2164         /* remember actual i/o configuration (for later placeholder
2165          * in case the plugin goes missing) */
2166         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2167         node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2168         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2169         node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2170
2171         /* save custom i/o config */
2172         node.add_property("custom", _custom_cfg ? "yes" : "no");
2173         for (uint32_t pc = 0; pc < get_count(); ++pc) {
2174                 char tmp[128];
2175                 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2176                 node.add_child_nocopy (* _in_map[pc].state (tmp));
2177                 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2178                 node.add_child_nocopy (* _out_map[pc].state (tmp));
2179         }
2180         node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2181
2182         if (_sidechain) {
2183                 node.add_child_nocopy (_sidechain->state (full));
2184         }
2185
2186         _plugins[0]->set_insert_id(this->id());
2187         node.add_child_nocopy (_plugins[0]->get_state());
2188
2189         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2190                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2191                 if (ac) {
2192                         node.add_child_nocopy (ac->get_state());
2193                 }
2194         }
2195
2196         return node;
2197 }
2198
2199 void
2200 PluginInsert::set_control_ids (const XMLNode& node, int version)
2201 {
2202         const XMLNodeList& nlist = node.children();
2203         XMLNodeConstIterator iter;
2204         set<Evoral::Parameter>::const_iterator p;
2205
2206         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2207                 if ((*iter)->name() == Controllable::xml_node_name) {
2208                         XMLProperty const * prop;
2209
2210                         uint32_t p = (uint32_t)-1;
2211 #ifdef LV2_SUPPORT
2212                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
2213                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2214                                 if (lv2plugin) {
2215                                         p = lv2plugin->port_index(prop->value().c_str());
2216                                 }
2217                         }
2218 #endif
2219                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
2220                                 p = atoi (prop->value());
2221                         }
2222
2223                         if (p != (uint32_t)-1) {
2224
2225                                 /* this may create the new controllable */
2226
2227                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2228
2229 #ifndef NO_PLUGIN_STATE
2230                                 if (!c) {
2231                                         continue;
2232                                 }
2233                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2234                                 if (ac) {
2235                                         ac->set_state (**iter, version);
2236                                 }
2237 #endif
2238                         }
2239                 }
2240         }
2241 }
2242
2243 int
2244 PluginInsert::set_state(const XMLNode& node, int version)
2245 {
2246         XMLNodeList nlist = node.children();
2247         XMLNodeIterator niter;
2248         XMLPropertyList plist;
2249         XMLProperty const * prop;
2250         ARDOUR::PluginType type;
2251
2252         if ((prop = node.property ("type")) == 0) {
2253                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2254                 return -1;
2255         }
2256
2257         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2258                 type = ARDOUR::LADSPA;
2259         } else if (prop->value() == X_("lv2")) {
2260                 type = ARDOUR::LV2;
2261         } else if (prop->value() == X_("windows-vst")) {
2262                 type = ARDOUR::Windows_VST;
2263         } else if (prop->value() == X_("lxvst")) {
2264                 type = ARDOUR::LXVST;
2265         } else if (prop->value() == X_("audiounit")) {
2266                 type = ARDOUR::AudioUnit;
2267         } else if (prop->value() == X_("luaproc")) {
2268                 type = ARDOUR::Lua;
2269         } else {
2270                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2271                                   prop->value())
2272                       << endmsg;
2273                 return -1;
2274         }
2275
2276         prop = node.property ("unique-id");
2277
2278         if (prop == 0) {
2279 #ifdef WINDOWS_VST_SUPPORT
2280                 /* older sessions contain VST plugins with only an "id" field.
2281                  */
2282
2283                 if (type == ARDOUR::Windows_VST) {
2284                         prop = node.property ("id");
2285                 }
2286 #endif
2287
2288 #ifdef LXVST_SUPPORT
2289                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2290
2291                 if (type == ARDOUR::LXVST) {
2292                         prop = node.property ("id");
2293                 }
2294 #endif
2295                 /* recheck  */
2296
2297                 if (prop == 0) {
2298                         error << _("Plugin has no unique ID field") << endmsg;
2299                         return -1;
2300                 }
2301         }
2302
2303         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2304
2305         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2306          * allow to move sessions windows <> linux */
2307 #ifdef LXVST_SUPPORT
2308         if (plugin == 0 && type == ARDOUR::Windows_VST) {
2309                 type = ARDOUR::LXVST;
2310                 plugin = find_plugin (_session, prop->value(), type);
2311         }
2312 #endif
2313
2314 #ifdef WINDOWS_VST_SUPPORT
2315         if (plugin == 0 && type == ARDOUR::LXVST) {
2316                 type = ARDOUR::Windows_VST;
2317                 plugin = find_plugin (_session, prop->value(), type);
2318         }
2319 #endif
2320
2321         if (plugin == 0 && type == ARDOUR::Lua) {
2322                 /* unique ID (sha1 of script) was not found,
2323                  * load the plugin from the serialized version in the
2324                  * session-file instead.
2325                  */
2326                 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2327                 XMLNode *ls = node.child (lp->state_node_name().c_str());
2328                 if (ls && lp) {
2329                         lp->set_script_from_state (*ls);
2330                         plugin = lp;
2331                 }
2332         }
2333
2334         if (plugin == 0) {
2335                 error << string_compose(
2336                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2337                           "Perhaps it was removed or moved since it was last used."),
2338                         prop->value())
2339                       << endmsg;
2340                 return -1;
2341         }
2342
2343         // The name of the PluginInsert comes from the plugin, nothing else
2344         _name = plugin->get_info()->name;
2345
2346         uint32_t count = 1;
2347
2348         // Processor::set_state() will set this, but too late
2349         // for it to be available when setting up plugin
2350         // state. We can't call Processor::set_state() until
2351         // the plugins themselves are created and added.
2352
2353         set_id (node);
2354
2355         if (_plugins.empty()) {
2356                 /* if we are adding the first plugin, we will need to set
2357                    up automatable controls.
2358                 */
2359                 add_plugin (plugin);
2360                 create_automatable_parameters ();
2361                 set_control_ids (node, version);
2362         }
2363
2364         if ((prop = node.property ("count")) != 0) {
2365                 sscanf (prop->value().c_str(), "%u", &count);
2366         }
2367
2368         if (_plugins.size() != count) {
2369                 for (uint32_t n = 1; n < count; ++n) {
2370                         add_plugin (plugin_factory (plugin));
2371                 }
2372         }
2373
2374         Processor::set_state (node, version);
2375
2376         PBD::ID new_id = this->id();
2377         PBD::ID old_id = this->id();
2378
2379         if ((prop = node.property ("id")) != 0) {
2380                 old_id = prop->value ();
2381         }
2382
2383         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2384
2385                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2386                    and set all plugins to the same state.
2387                 */
2388
2389                 if ((*niter)->name() == plugin->state_node_name()) {
2390
2391                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2392                                 /* Plugin state can include external files which are named after the ID.
2393                                  *
2394                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
2395                                  * been changed, so we need to use the old ID from the XML to load the
2396                                  * state and then update the ID.
2397                                  *
2398                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
2399                                  * but we need to call set_insert_id() to clear the cached plugin-state
2400                                  * and force a change.
2401                                  */
2402                                 if (!regenerate_xml_or_string_ids ()) {
2403                                         (*i)->set_insert_id (new_id);
2404                                 } else {
2405                                         (*i)->set_insert_id (old_id);
2406                                 }
2407
2408                                 (*i)->set_state (**niter, version);
2409
2410                                 if (regenerate_xml_or_string_ids ()) {
2411                                         (*i)->set_insert_id (new_id);
2412                                 }
2413                         }
2414
2415                         break;
2416                 }
2417         }
2418
2419         if (version < 3000) {
2420
2421                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2422                    this is all handled by Automatable
2423                 */
2424
2425                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2426                         if ((*niter)->name() == "Redirect") {
2427                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2428                                 Processor::set_state (**niter, version);
2429                                 break;
2430                         }
2431                 }
2432
2433                 set_parameter_state_2X (node, version);
2434         }
2435
2436         if ((prop = node.property (X_("custom"))) != 0) {
2437                 _custom_cfg = string_is_affirmative (prop->value());
2438         }
2439
2440         uint32_t in_maps = 0;
2441         uint32_t out_maps = 0;
2442         XMLNodeList kids = node.children ();
2443         for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2444                 if ((*i)->name() == X_("ConfiguredInput")) {
2445                         _configured_in = ChanCount(**i);
2446                 }
2447                 if ((*i)->name() == X_("CustomSinks")) {
2448                         _custom_sinks = ChanCount(**i);
2449                 }
2450                 if ((*i)->name() == X_("ConfiguredOutput")) {
2451                         _custom_out = ChanCount(**i);
2452                         _configured_out = ChanCount(**i);
2453                 }
2454                 if ((*i)->name() == X_("PresetOutput")) {
2455                         _preset_out = ChanCount(**i);
2456                 }
2457                 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2458                         long pc = atol (&((*i)->name().c_str()[9]));
2459                         if (pc >= 0 && pc <= (long) get_count()) {
2460                                 _in_map[pc] = ChanMapping (**i);
2461                                 ++in_maps;
2462                         }
2463                 }
2464                 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2465                         long pc = atol (&((*i)->name().c_str()[10]));
2466                         if (pc >= 0 && pc <= (long) get_count()) {
2467                                 _out_map[pc] = ChanMapping (**i);
2468                                 ++out_maps;
2469                         }
2470                 }
2471                 if ((*i)->name () ==  "ThruMap") {
2472                                 _thru_map = ChanMapping (**i);
2473                 }
2474
2475                 // sidechain is a Processor (IO)
2476                 if ((*i)->name () ==  Processor::state_node_name) {
2477                         if (!_sidechain) {
2478                                 add_sidechain (0);
2479                         }
2480                         _sidechain->set_state (**i, version);
2481                 }
2482         }
2483
2484         if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2485                 _maps_from_state = true;
2486         }
2487
2488         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2489                 if (active()) {
2490                         (*i)->activate ();
2491                 } else {
2492                         (*i)->deactivate ();
2493                 }
2494         }
2495
2496         PluginConfigChanged (); /* EMIT SIGNAL */
2497         return 0;
2498 }
2499
2500 void
2501 PluginInsert::update_id (PBD::ID id)
2502 {
2503         set_id (id.to_s());
2504         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2505                 (*i)->set_insert_id (id);
2506         }
2507 }
2508
2509 void
2510 PluginInsert::set_state_dir (const std::string& d)
2511 {
2512         // state() only saves the state of the first plugin
2513         _plugins[0]->set_state_dir (d);
2514 }
2515
2516 void
2517 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2518 {
2519         XMLNodeList nlist = node.children();
2520         XMLNodeIterator niter;
2521
2522         /* look for port automation node */
2523
2524         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2525
2526                 if ((*niter)->name() != port_automation_node_name) {
2527                         continue;
2528                 }
2529
2530                 XMLNodeList cnodes;
2531                 XMLProperty const * cprop;
2532                 XMLNodeConstIterator iter;
2533                 XMLNode *child;
2534                 const char *port;
2535                 uint32_t port_id;
2536
2537                 cnodes = (*niter)->children ("port");
2538
2539                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2540
2541                         child = *iter;
2542
2543                         if ((cprop = child->property("number")) != 0) {
2544                                 port = cprop->value().c_str();
2545                         } else {
2546                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2547                                 continue;
2548                         }
2549
2550                         sscanf (port, "%" PRIu32, &port_id);
2551
2552                         if (port_id >= _plugins[0]->parameter_count()) {
2553                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2554                                 continue;
2555                         }
2556
2557                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2558                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2559
2560                         if (c && c->alist()) {
2561                                 if (!child->children().empty()) {
2562                                         c->alist()->set_state (*child->children().front(), version);
2563
2564                                         /* In some cases 2.X saves lists with min_yval and max_yval
2565                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
2566                                            in A3 because these min/max values are used to compute
2567                                            where GUI control points should be drawn.  If we see such
2568                                            values, `correct' them to the min/max of the appropriate
2569                                            parameter.
2570                                         */
2571
2572                                         float min_y = c->alist()->get_min_y ();
2573                                         float max_y = c->alist()->get_max_y ();
2574
2575                                         ParameterDescriptor desc;
2576                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
2577
2578                                         if (min_y == FLT_MIN) {
2579                                                 min_y = desc.lower;
2580                                         }
2581
2582                                         if (max_y == FLT_MAX) {
2583                                                 max_y = desc.upper;
2584                                         }
2585
2586                                         c->alist()->set_yrange (min_y, max_y);
2587                                 }
2588                         } else {
2589                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2590                         }
2591                 }
2592
2593                 /* done */
2594
2595                 break;
2596         }
2597 }
2598
2599
2600 string
2601 PluginInsert::describe_parameter (Evoral::Parameter param)
2602 {
2603         if (param.type() == PluginAutomation) {
2604                 return _plugins[0]->describe_parameter (param);
2605         } else if (param.type() == PluginPropertyAutomation) {
2606                 boost::shared_ptr<AutomationControl> c(automation_control(param));
2607                 if (c && !c->desc().label.empty()) {
2608                         return c->desc().label;
2609                 }
2610         }
2611         return Automatable::describe_parameter(param);
2612 }
2613
2614 ARDOUR::framecnt_t
2615 PluginInsert::signal_latency() const
2616 {
2617         if (_user_latency) {
2618                 return _user_latency;
2619         }
2620
2621         return _plugins[0]->signal_latency ();
2622 }
2623
2624 ARDOUR::PluginType
2625 PluginInsert::type ()
2626 {
2627        return plugin()->get_info()->type;
2628 }
2629
2630 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
2631                                             const Evoral::Parameter&          param,
2632                                             const ParameterDescriptor&        desc,
2633                                             boost::shared_ptr<AutomationList> list)
2634         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2635         , _plugin (p)
2636 {
2637         if (alist()) {
2638                 alist()->reset_default (desc.normal);
2639                 if (desc.toggled) {
2640                         list->set_interpolation(Evoral::ControlList::Discrete);
2641                 }
2642         }
2643 }
2644
2645 /** @param val `user' value */
2646
2647 void
2648 PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2649 {
2650         /* FIXME: probably should be taking out some lock here.. */
2651
2652         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2653                 (*i)->set_parameter (_list->parameter().id(), user_val);
2654         }
2655
2656         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2657         if (iasp) {
2658                 iasp->set_parameter (_list->parameter().id(), user_val);
2659         }
2660
2661         AutomationControl::actually_set_value (user_val, group_override);
2662 }
2663
2664 void
2665 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2666 {
2667         AutomationControl::actually_set_value (user_val, Controllable::NoGroup);
2668 }
2669
2670 XMLNode&
2671 PluginInsert::PluginControl::get_state ()
2672 {
2673         stringstream ss;
2674
2675         XMLNode& node (AutomationControl::get_state());
2676         ss << parameter().id();
2677         node.add_property (X_("parameter"), ss.str());
2678 #ifdef LV2_SUPPORT
2679         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2680         if (lv2plugin) {
2681                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2682         }
2683 #endif
2684
2685         return node;
2686 }
2687
2688 /** @return `user' val */
2689 double
2690 PluginInsert::PluginControl::get_value () const
2691 {
2692         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2693
2694         if (!plugin) {
2695                 return 0.0;
2696         }
2697
2698         return plugin->get_parameter (_list->parameter().id());
2699 }
2700
2701 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
2702                                                             const Evoral::Parameter&          param,
2703                                                             const ParameterDescriptor&        desc,
2704                                                             boost::shared_ptr<AutomationList> list)
2705         : AutomationControl (p->session(), param, desc, list)
2706         , _plugin (p)
2707 {
2708         if (alist()) {
2709                 alist()->set_yrange (desc.lower, desc.upper);
2710                 alist()->reset_default (desc.normal);
2711         }
2712 }
2713
2714 void
2715 PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd)
2716 {
2717         /* Old numeric set_value(), coerce to appropriate datatype if possible.
2718            This is lossy, but better than nothing until Ardour's automation system
2719            can handle various datatypes all the way down. */
2720         const Variant value(_desc.datatype, user_val);
2721         if (value.type() == Variant::NOTHING) {
2722                 error << "set_value(double) called for non-numeric property" << endmsg;
2723                 return;
2724         }
2725
2726         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2727                 (*i)->set_property(_list->parameter().id(), value);
2728         }
2729
2730         _value = value;
2731
2732         AutomationControl::actually_set_value (user_val, gcd);
2733 }
2734
2735 XMLNode&
2736 PluginInsert::PluginPropertyControl::get_state ()
2737 {
2738         stringstream ss;
2739
2740         XMLNode& node (AutomationControl::get_state());
2741         ss << parameter().id();
2742         node.add_property (X_("property"), ss.str());
2743         node.remove_property (X_("value"));
2744
2745         return node;
2746 }
2747
2748 double
2749 PluginInsert::PluginPropertyControl::get_value () const
2750 {
2751         return _value.to_double();
2752 }
2753
2754 boost::shared_ptr<Plugin>
2755 PluginInsert::get_impulse_analysis_plugin()
2756 {
2757         boost::shared_ptr<Plugin> ret;
2758         if (_impulseAnalysisPlugin.expired()) {
2759                 // LV2 in particular uses various _session params
2760                 // during init() -- most notably block_size..
2761                 // not great.
2762                 ret = plugin_factory(_plugins[0]);
2763                 ret->configure_io (internal_input_streams (), internal_output_streams ());
2764                 _impulseAnalysisPlugin = ret;
2765         } else {
2766                 ret = _impulseAnalysisPlugin.lock();
2767         }
2768
2769         return ret;
2770 }
2771
2772 void
2773 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2774 {
2775         // called from outside the audio thread, so this should be safe
2776         // only do audio as analysis is (currently) only for audio plugins
2777         _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(),  nframes);
2778         _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
2779
2780         _signal_analysis_collected_nframes   = 0;
2781         _signal_analysis_collect_nframes_max = nframes;
2782 }
2783
2784 /** Add a plugin to our list */
2785 void
2786 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2787 {
2788         plugin->set_insert_id (this->id());
2789
2790         if (_plugins.empty()) {
2791                 /* first (and probably only) plugin instance - connect to relevant signals */
2792
2793                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2794                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2795                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2796                 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2797                 _custom_sinks = plugin->get_info()->n_inputs;
2798                 // cache sidechain port count
2799                 _cached_sidechain_pins.reset ();
2800                 const ChanCount& nis (plugin->get_info()->n_inputs);
2801                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2802                         for (uint32_t in = 0; in < nis.get (*t); ++in) {
2803                                 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2804                                 if (iod.is_sidechain) {
2805                                         _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2806                                 }
2807                         }
2808                 }
2809         }
2810 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2811         boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2812         if (vst) {
2813                 vst->set_insert (this, _plugins.size ());
2814         }
2815 #endif
2816         _plugins.push_back (plugin);
2817 }
2818
2819 bool
2820 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
2821 {
2822         bool ok = true;
2823         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2824                 if (! (*i)->load_preset (pr)) {
2825                         ok = false;
2826                 }
2827         }
2828         return ok;
2829 }
2830
2831 void
2832 PluginInsert::realtime_handle_transport_stopped ()
2833 {
2834         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2835                 (*i)->realtime_handle_transport_stopped ();
2836         }
2837 }
2838
2839 void
2840 PluginInsert::realtime_locate ()
2841 {
2842         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2843                 (*i)->realtime_locate ();
2844         }
2845 }
2846
2847 void
2848 PluginInsert::monitoring_changed ()
2849 {
2850         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2851                 (*i)->monitoring_changed ();
2852         }
2853 }
2854
2855 void
2856 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2857 {
2858         // this is called in RT context, LatencyChanged is emitted after run()
2859         _latency_changed = true;
2860 }
2861
2862 void
2863 PluginInsert::start_touch (uint32_t param_id)
2864 {
2865         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2866         if (ac) {
2867                 ac->start_touch (session().audible_frame());
2868         }
2869 }
2870
2871 void
2872 PluginInsert::end_touch (uint32_t param_id)
2873 {
2874         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2875         if (ac) {
2876                 ac->stop_touch (true, session().audible_frame());
2877         }
2878 }
2879
2880 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2881 {
2882         switch (m.method) {
2883                 case PluginInsert::Impossible: o << "Impossible"; break;
2884                 case PluginInsert::Delegate:   o << "Delegate"; break;
2885                 case PluginInsert::NoInputs:   o << "NoInputs"; break;
2886                 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2887                 case PluginInsert::Replicate:  o << "Replicate"; break;
2888                 case PluginInsert::Split:      o << "Split"; break;
2889                 case PluginInsert::Hide:       o << "Hide"; break;
2890         }
2891         o << " cnt: " << m.plugins
2892                 << (m.strict_io ? " strict-io" : "")
2893                 << (m.custom_cfg ? " custom-cfg" : "");
2894         if (m.method == PluginInsert::Hide) {
2895                 o << " hide: " << m.hide;
2896         }
2897         o << "\n";
2898         return o;
2899 }