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