libs/ardour/plugin_insert.cc

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