libs/ardour/plugin_insert.cc

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