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