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