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