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 {
  72         /* the first is the master */
  73
  74         if (plug) {
  75                 add_plugin (plug);
  76                 create_automatable_parameters ();
  77         }
  78 }
  79
  80 bool
  81 PluginInsert::set_count (uint32_t num)
  82 {
  83         bool require_state = !_plugins.empty();
  84
  85         /* this is a bad idea.... we shouldn't do this while active.
  86            only a route holding their redirect_lock should be calling this
  87         */
  88
  89         if (num == 0) {
  90                 return false;
  91         } else if (num > _plugins.size()) {
  92                 uint32_t diff = num - _plugins.size();
  93
  94                 for (uint32_t n = 0; n < diff; ++n) {
  95                         boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
  96                         add_plugin (p);
  97                         if (active ()) {
  98                                 p->activate ();
  99                         }
 100
 101                         if (require_state) {
 102                                 /* XXX do something */
 103                         }
 104                 }
 105
 106         } else if (num < _plugins.size()) {
 107                 uint32_t diff = _plugins.size() - num;
 108                 for (uint32_t n= 0; n < diff; ++n) {
 109                         _plugins.pop_back();
 110                 }
 111         }
 112
 113         return true;
 114 }
 115
 116 PluginInsert::~PluginInsert ()
 117 {
 118 }
 119
 120 void
 121 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
 122 {
 123         if (which.type() != PluginAutomation)
 124                 return;
 125
 126         boost::shared_ptr<AutomationControl> c
 127                         = boost::dynamic_pointer_cast<AutomationControl>(control (which));
 128
 129         if (c && s != Off) {
 130                 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
 131         }
 132 }
 133
 134 ChanCount
 135 PluginInsert::output_streams() const
 136 {
 137         assert (!_plugins.empty());
 138
 139         PluginInfoPtr info = _plugins.front()->get_info();
 140
 141         if (info->reconfigurable_io()) {
 142                 ChanCount out = _plugins.front()->output_streams ();
 143                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
 144                 return out;
 145         } else {
 146                 ChanCount out = info->n_outputs;
 147                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
 148                 out.set_audio (out.n_audio() * _plugins.size());
 149                 out.set_midi (out.n_midi() * _plugins.size() + midi_bypass.n_midi());
 150                 return out;
 151         }
 152 }
 153
 154 ChanCount
 155 PluginInsert::input_streams() const
 156 {
 157         assert (!_plugins.empty());
 158
 159         ChanCount in;
 160
 161         PluginInfoPtr info = _plugins.front()->get_info();
 162
 163         if (info->reconfigurable_io()) {
 164                 assert (_plugins.size() == 1);
 165                 in = _plugins.front()->input_streams();
 166         } else {
 167                 in = info->n_inputs;
 168         }
 169
 170         DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
 171
 172         if (_match.method == Split) {
 173
 174                 /* we are splitting 1 processor input to multiple plugin inputs,
 175                    so we have a maximum of 1 stream of each type.
 176                 */
 177                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 178                         if (in.get (*t) > 1) {
 179                                 in.set (*t, 1);
 180                         }
 181                 }
 182                 return in;
 183
 184         } else if (_match.method == Hide) {
 185
 186                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 187                         in.set (*t, in.get (*t) - _match.hide.get (*t));
 188                 }
 189                 return in;
 190
 191         } else {
 192
 193                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 194                         in.set (*t, in.get (*t) * _plugins.size ());
 195                 }
 196
 197                 return in;
 198         }
 199 }
 200
 201 ChanCount
 202 PluginInsert::natural_output_streams() const
 203 {
 204         return _plugins[0]->get_info()->n_outputs;
 205 }
 206
 207 ChanCount
 208 PluginInsert::natural_input_streams() const
 209 {
 210         return _plugins[0]->get_info()->n_inputs;
 211 }
 212
 213 bool
 214 PluginInsert::has_no_inputs() const
 215 {
 216         return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
 217 }
 218
 219 bool
 220 PluginInsert::has_no_audio_inputs() const
 221 {
 222         return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
 223 }
 224
 225 bool
 226 PluginInsert::is_midi_instrument() const
 227 {
 228         /* XXX more finesse is possible here. VST plugins have a
 229            a specific "instrument" flag, for example.
 230          */
 231         PluginInfoPtr pi = _plugins[0]->get_info();
 232
 233         return pi->n_inputs.n_midi() != 0 &&
 234                 pi->n_outputs.n_audio() > 0;
 235 }
 236
 237 void
 238 PluginInsert::create_automatable_parameters ()
 239 {
 240         assert (!_plugins.empty());
 241
 242         set<Evoral::Parameter> a = _plugins.front()->automatable ();
 243
 244         for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
 245                 if (i->type() == PluginAutomation) {
 246
 247                         Evoral::Parameter param(*i);
 248
 249                         ParameterDescriptor desc;
 250                         _plugins.front()->get_parameter_descriptor(i->id(), desc);
 251
 252                         can_automate (param);
 253                         boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
 254                         boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
 255                         add_control (c);
 256                         _plugins.front()->set_automation_control (i->id(), c);
 257                 } else if (i->type() == PluginPropertyAutomation) {
 258                         Evoral::Parameter param(*i);
 259                         const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
 260                         if (desc.datatype != Variant::NOTHING) {
 261                                 boost::shared_ptr<AutomationList> list;
 262                                 if (Variant::type_is_numeric(desc.datatype)) {
 263                                         list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
 264                                 }
 265                                 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
 266                         }
 267                 }
 268         }
 269 }
 270 /** Called when something outside of this host has modified a plugin
 271  * parameter. Responsible for propagating the change to two places:
 272  *
 273  *   1) anything listening to the Control itself
 274  *   2) any replicated plugins that make up this PluginInsert.
 275  *
 276  * The PluginInsert is connected to the ParameterChangedExternally signal for
 277  * the first (primary) plugin, and here broadcasts that change to any others.
 278  *
 279  * XXX We should probably drop this whole replication idea (Paul, October 2015)
 280  * since it isn't used by sensible plugin APIs (AU, LV2).
 281  */
 282 void
 283 PluginInsert::parameter_changed_externally (uint32_t which, float val)
 284 {
 285         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
 286
 287         /* First propagation: alter the underlying value of the control,
 288          * without telling the plugin(s) that own/use it to set it.
 289          */
 290
 291         if (!ac) {
 292                 return;
 293         }
 294
 295         boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
 296
 297         if (pc) {
 298                 pc->catch_up_with_external_value (val);
 299         }
 300
 301         /* Second propagation: tell all plugins except the first to
 302            update the value of this parameter. For sane plugin APIs,
 303            there are no other plugins, so this is a no-op in those
 304            cases.
 305         */
 306
 307         Plugins::iterator i = _plugins.begin();
 308
 309         /* don't set the first plugin, just all the slaves */
 310
 311         if (i != _plugins.end()) {
 312                 ++i;
 313                 for (; i != _plugins.end(); ++i) {
 314                         (*i)->set_parameter (which, val);
 315                 }
 316         }
 317 }
 318
 319 int
 320 PluginInsert::set_block_size (pframes_t nframes)
 321 {
 322         int ret = 0;
 323         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 324                 if ((*i)->set_block_size (nframes) != 0) {
 325                         ret = -1;
 326                 }
 327         }
 328         return ret;
 329 }
 330
 331 void
 332 PluginInsert::activate ()
 333 {
 334         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 335                 (*i)->activate ();
 336         }
 337
 338         Processor::activate ();
 339 }
 340
 341 void
 342 PluginInsert::deactivate ()
 343 {
 344         Processor::deactivate ();
 345
 346         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 347                 (*i)->deactivate ();
 348         }
 349 }
 350
 351 void
 352 PluginInsert::flush ()
 353 {
 354         for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 355                 (*i)->flush ();
 356         }
 357 }
 358
 359 void
 360 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
 361 {
 362         // Calculate if, and how many frames we need to collect for analysis
 363         framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
 364                                              _signal_analysis_collected_nframes);
 365         if (nframes < collect_signal_nframes) { // we might not get all frames now
 366                 collect_signal_nframes = nframes;
 367         }
 368
 369         ChanCount const in_streams = input_streams ();
 370         ChanCount const out_streams = output_streams ();
 371
 372         ChanMapping in_map (in_streams);
 373         ChanMapping out_map (out_streams);
 374         bool valid;
 375         if (_match.method == Split) {
 376                 /* fix the input mapping so that we have maps for each of the plugin's inputs */
 377                 in_map = ChanMapping (natural_input_streams ());
 378
 379                 /* copy the first stream's buffer contents to the others */
 380                 /* XXX: audio only */
 381                 uint32_t first_idx = in_map.get (DataType::AUDIO, 0, &valid);
 382                 if (valid) {
 383                         for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
 384                                 bufs.get_audio(in_map.get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
 385                         }
 386                 }
 387         }
 388
 389         bufs.set_count(ChanCount::max(bufs.count(), in_streams));
 390         bufs.set_count(ChanCount::max(bufs.count(), out_streams));
 391
 392         /* Note that we've already required that plugins
 393            be able to handle in-place processing.
 394         */
 395
 396         if (with_auto) {
 397
 398                 uint32_t n = 0;
 399
 400                 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
 401
 402                         boost::shared_ptr<AutomationControl> c
 403                                 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
 404
 405                         if (c->list() && c->automation_playback()) {
 406                                 bool valid;
 407
 408                                 const float val = c->list()->rt_safe_eval (now, valid);
 409
 410                                 if (valid) {
 411                                         /* This is the ONLY place where we are
 412                                          *  allowed to call
 413                                          *  AutomationControl::set_value_unchecked(). We
 414                                          *  know that the control is in
 415                                          *  automation playback mode, so no
 416                                          *  check on writable() is required
 417                                          *  (which must be done in AutomationControl::set_value()
 418                                          *
 419                                          */
 420                                         c->set_value_unchecked(val);
 421                                 }
 422
 423                         }
 424                 }
 425         }
 426
 427         if (collect_signal_nframes > 0) {
 428                 // collect input
 429                 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 430                 //std::cerr << "               streams " << input_streams().n_audio() << std::endl;
 431                 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
 432
 433                 _signal_analysis_inputs.set_count(input_streams());
 434
 435                 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
 436                         _signal_analysis_inputs.get_audio(i).read_from(
 437                                 bufs.get_audio(i),
 438                                 collect_signal_nframes,
 439                                 _signal_analysis_collected_nframes); // offset is for target buffer
 440                 }
 441
 442         }
 443
 444         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 445                 if ((*i)->connect_and_run(bufs, in_map, out_map, nframes, offset)) {
 446                         deactivate ();
 447                 }
 448                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 449                         in_map.offset_to(*t, natural_input_streams().get(*t));
 450                         out_map.offset_to(*t, natural_output_streams().get(*t));
 451                 }
 452         }
 453
 454         if (collect_signal_nframes > 0) {
 455                 // collect output
 456                 //std::cerr << "       output, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 457                 //std::cerr << "               streams " << output_streams().n_audio() << std::endl;
 458
 459                 _signal_analysis_outputs.set_count(output_streams());
 460
 461                 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
 462                         _signal_analysis_outputs.get_audio(i).read_from(
 463                                 bufs.get_audio(i),
 464                                 collect_signal_nframes,
 465                                 _signal_analysis_collected_nframes); // offset is for target buffer
 466                 }
 467
 468                 _signal_analysis_collected_nframes += collect_signal_nframes;
 469                 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
 470
 471                 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
 472                         _signal_analysis_collect_nframes_max = 0;
 473                         _signal_analysis_collected_nframes   = 0;
 474
 475                         AnalysisDataGathered(&_signal_analysis_inputs,
 476                                              &_signal_analysis_outputs);
 477                 }
 478         }
 479         /* leave remaining channel buffers alone */
 480 }
 481
 482 void
 483 PluginInsert::silence (framecnt_t nframes)
 484 {
 485         if (!active ()) {
 486                 return;
 487         }
 488
 489         ChanMapping in_map(input_streams());
 490         ChanMapping out_map(output_streams());
 491
 492         if (_match.method == Split) {
 493                 /* fix the input mapping so that we have maps for each of the plugin's inputs */
 494                 in_map = ChanMapping (natural_input_streams ());
 495         }
 496
 497         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 498                 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
 499         }
 500 }
 501
 502 void
 503 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
 504 {
 505         if (_pending_active) {
 506                 /* run as normal if we are active or moving from inactive to active */
 507
 508                 if (_session.transport_rolling() || _session.bounce_processing()) {
 509                         automation_run (bufs, start_frame, nframes);
 510                 } else {
 511                         connect_and_run (bufs, nframes, 0, false);
 512                 }
 513
 514         } else {
 515                 uint32_t in = input_streams ().n_audio ();
 516                 uint32_t out = output_streams().n_audio ();
 517
 518                 if (has_no_audio_inputs() || in == 0) {
 519
 520                         /* silence all (audio) outputs. Should really declick
 521                          * at the transitions of "active"
 522                          */
 523
 524                         for (uint32_t n = 0; n < out; ++n) {
 525                                 bufs.get_audio (n).silence (nframes);
 526                         }
 527
 528                 } else if (out > in) {
 529
 530                         /* not active, but something has make up for any channel count increase */
 531
 532                         // TODO: option round-robin (n % in) or silence additional buffers ??
 533                         // for now , simply replicate last buffer
 534                         for (uint32_t n = in; n < out; ++n) {
 535                                 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
 536                         }
 537                 }
 538
 539                 bufs.count().set_audio (out);
 540         }
 541
 542         _active = _pending_active;
 543
 544         /* we have no idea whether the plugin generated silence or not, so mark
 545          * all buffers appropriately.
 546          */
 547
 548 }
 549
 550 void
 551 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
 552 {
 553         Evoral::ControlEvent next_event (0, 0.0f);
 554         framepos_t now = start;
 555         framepos_t end = now + nframes;
 556         framecnt_t offset = 0;
 557
 558         Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
 559
 560         if (!lm.locked()) {
 561                 connect_and_run (bufs, nframes, offset, false);
 562                 return;
 563         }
 564
 565         if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
 566
 567                 /* no events have a time within the relevant range */
 568
 569                 connect_and_run (bufs, nframes, offset, true, now);
 570                 return;
 571         }
 572
 573         while (nframes) {
 574
 575                 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
 576
 577                 connect_and_run (bufs, cnt, offset, true, now);
 578
 579                 nframes -= cnt;
 580                 offset += cnt;
 581                 now += cnt;
 582
 583                 if (!find_next_event (now, end, next_event)) {
 584                         break;
 585                 }
 586         }
 587
 588         /* cleanup anything that is left to do */
 589
 590         if (nframes) {
 591                 connect_and_run (bufs, nframes, offset, true, now);
 592         }
 593 }
 594
 595 float
 596 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
 597 {
 598         if (param.type() != PluginAutomation)
 599                 return 1.0;
 600
 601         if (_plugins.empty()) {
 602                 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
 603                       << endmsg;
 604                 abort(); /*NOTREACHED*/
 605         }
 606
 607         return _plugins[0]->default_value (param.id());
 608 }
 609
 610
 611 bool
 612 PluginInsert::can_reset_all_parameters ()
 613 {
 614         bool all = true;
 615         uint32_t params = 0;
 616         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 617                 bool ok=false;
 618                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 619
 620                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 621                         continue;
 622                 }
 623
 624                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 625                 if (!ac) {
 626                         continue;
 627                 }
 628
 629                 ++params;
 630                 if (ac->automation_state() & Play) {
 631                         all = false;
 632                         break;
 633                 }
 634         }
 635         return all && (params > 0);
 636 }
 637
 638 bool
 639 PluginInsert::reset_parameters_to_default ()
 640 {
 641         bool all = true;
 642
 643         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 644                 bool ok=false;
 645                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 646
 647                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 648                         continue;
 649                 }
 650
 651                 const float dflt = _plugins[0]->default_value (cid);
 652                 const float curr = _plugins[0]->get_parameter (cid);
 653
 654                 if (dflt == curr) {
 655                         continue;
 656                 }
 657
 658                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 659                 if (!ac) {
 660                         continue;
 661                 }
 662
 663                 if (ac->automation_state() & Play) {
 664                         all = false;
 665                         continue;
 666                 }
 667
 668                 ac->set_value (dflt, Controllable::NoGroup);
 669         }
 670         return all;
 671 }
 672
 673 boost::shared_ptr<Plugin>
 674 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
 675 {
 676         boost::shared_ptr<LadspaPlugin> lp;
 677         boost::shared_ptr<LuaProc> lua;
 678 #ifdef LV2_SUPPORT
 679         boost::shared_ptr<LV2Plugin> lv2p;
 680 #endif
 681 #ifdef WINDOWS_VST_SUPPORT
 682         boost::shared_ptr<WindowsVSTPlugin> vp;
 683 #endif
 684 #ifdef LXVST_SUPPORT
 685         boost::shared_ptr<LXVSTPlugin> lxvp;
 686 #endif
 687 #ifdef AUDIOUNIT_SUPPORT
 688         boost::shared_ptr<AUPlugin> ap;
 689 #endif
 690
 691         if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
 692                 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
 693         } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
 694                 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
 695 #ifdef LV2_SUPPORT
 696         } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
 697                 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
 698 #endif
 699 #ifdef WINDOWS_VST_SUPPORT
 700         } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
 701                 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
 702 #endif
 703 #ifdef LXVST_SUPPORT
 704         } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
 705                 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
 706 #endif
 707 #ifdef AUDIOUNIT_SUPPORT
 708         } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
 709                 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
 710 #endif
 711         }
 712
 713         fatal << string_compose (_("programming error: %1"),
 714                           X_("unknown plugin type in PluginInsert::plugin_factory"))
 715               << endmsg;
 716         abort(); /*NOTREACHED*/
 717         return boost::shared_ptr<Plugin> ((Plugin*) 0);
 718 }
 719
 720 bool
 721 PluginInsert::configure_io (ChanCount in, ChanCount out)
 722 {
 723         Match old_match = _match;
 724         ChanCount old_in = input_streams ();
 725         ChanCount old_out = output_streams ();
 726
 727         _configured_in = in;
 728         _configured_out = out;
 729
 730         /* set the matching method and number of plugins that we will use to meet this configuration */
 731         _match = private_can_support_io_configuration (in, out);
 732         if (set_count (_match.plugins) == false) {
 733                 PluginIoReConfigure (); /* EMIT SIGNAL */
 734                 return false;
 735         }
 736
 737         /* configure plugins */
 738         switch (_match.method) {
 739         case Split:
 740         case Hide:
 741                 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out) == false) {
 742                         PluginIoReConfigure (); /* EMIT SIGNAL */
 743                         return false;
 744                 }
 745                 break;
 746
 747         default:
 748                 if (_plugins.front()->configure_io (in, out) == false) {
 749                         PluginIoReConfigure (); /* EMIT SIGNAL */
 750                         return false;
 751                 }
 752                 break;
 753         }
 754
 755         if (  (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
 756                         || old_in != in
 757                         || old_out != out
 758                         )
 759         {
 760                 PluginIoReConfigure (); /* EMIT SIGNAL */
 761         }
 762
 763         // we don't know the analysis window size, so we must work with the
 764         // current buffer size here. each request for data fills in these
 765         // buffers and the analyser makes sure it gets enough data for the
 766         // analysis window
 767         session().ensure_buffer_set (_signal_analysis_inputs, in);
 768         //_signal_analysis_inputs.set_count (in);
 769
 770         session().ensure_buffer_set (_signal_analysis_outputs, out);
 771         //_signal_analysis_outputs.set_count (out);
 772
 773         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
 774
 775         return Processor::configure_io (in, out);
 776 }
 777
 778 /** Decide whether this PluginInsert can support a given IO configuration.
 779  *  To do this, we run through a set of possible solutions in rough order of
 780  *  preference.
 781  *
 782  *  @param in Required input channel count.
 783  *  @param out Filled in with the output channel count if we return true.
 784  *  @return true if the given IO configuration can be supported.
 785  */
 786 bool
 787 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 788 {
 789         return private_can_support_io_configuration (in, out).method != Impossible;
 790 }
 791
 792 /** A private version of can_support_io_configuration which returns the method
 793  *  by which the configuration can be matched, rather than just whether or not
 794  *  it can be.
 795  */
 796 PluginInsert::Match
 797 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
 798 {
 799         if (_plugins.empty()) {
 800                 return Match();
 801         }
 802
 803         PluginInfoPtr info = _plugins.front()->get_info();
 804         ChanCount in; in += inx;
 805         midi_bypass.reset();
 806
 807         if (info->reconfigurable_io()) {
 808                 /* Plugin has flexible I/O, so delegate to it */
 809                 bool const r = _plugins.front()->can_support_io_configuration (in, out);
 810                 if (!r) {
 811                         return Match (Impossible, 0);
 812                 }
 813
 814                 return Match (Delegate, 1);
 815         }
 816
 817         ChanCount inputs  = info->n_inputs;
 818         ChanCount outputs = info->n_outputs;
 819
 820         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
 821                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
 822                 midi_bypass.set(DataType::MIDI, 1);
 823         }
 824         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
 825                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
 826                 in.set(DataType::MIDI, 0);
 827         }
 828
 829         bool no_inputs = true;
 830         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 831                 if (inputs.get (*t) != 0) {
 832                         no_inputs = false;
 833                         break;
 834                 }
 835         }
 836
 837         if (no_inputs) {
 838                 /* no inputs so we can take any input configuration since we throw it away */
 839                 out = outputs + midi_bypass;
 840                 return Match (NoInputs, 1);
 841         }
 842
 843         /* Plugin inputs match requested inputs exactly */
 844         if (inputs == in) {
 845                 out = outputs + midi_bypass;
 846                 return Match (ExactMatch, 1);
 847         }
 848
 849         /* We may be able to run more than one copy of the plugin within this insert
 850            to cope with the insert having more inputs than the plugin.
 851            We allow replication only for plugins with either zero or 1 inputs and outputs
 852            for every valid data type.
 853         */
 854
 855         uint32_t f             = 0;
 856         bool     can_replicate = true;
 857         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 858
 859                 uint32_t nin = inputs.get (*t);
 860
 861                 // No inputs of this type
 862                 if (nin == 0 && in.get(*t) == 0) {
 863                         continue;
 864                 }
 865
 866                 if (nin != 1 || outputs.get (*t) != 1) {
 867                         can_replicate = false;
 868                         break;
 869                 }
 870
 871                 // Potential factor not set yet
 872                 if (f == 0) {
 873                         f = in.get(*t) / nin;
 874                 }
 875
 876                 // Factor for this type does not match another type, can not replicate
 877                 if (f != (in.get(*t) / nin)) {
 878                         can_replicate = false;
 879                         break;
 880                 }
 881         }
 882
 883         if (can_replicate) {
 884                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 885                         out.set (*t, outputs.get(*t) * f);
 886                 }
 887                 out += midi_bypass;
 888                 return Match (Replicate, f);
 889         }
 890
 891         /* If the processor has exactly one input of a given type, and
 892            the plugin has more, we can feed the single processor input
 893            to some or all of the plugin inputs.  This is rather
 894            special-case-y, but the 1-to-many case is by far the
 895            simplest.  How do I split thy 2 processor inputs to 3
 896            plugin inputs?  Let me count the ways ...
 897         */
 898
 899         bool can_split = true;
 900         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 901
 902                 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
 903                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
 904
 905                 if (!can_split_type && !nothing_to_do_for_type) {
 906                         can_split = false;
 907                 }
 908         }
 909
 910         if (can_split) {
 911                 out = outputs + midi_bypass;
 912                 return Match (Split, 1);
 913         }
 914
 915         /* If the plugin has more inputs than we want, we can `hide' some of them
 916            by feeding them silence.
 917         */
 918
 919         bool could_hide = false;
 920         bool cannot_hide = false;
 921         ChanCount hide_channels;
 922
 923         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 924                 if (inputs.get(*t) > in.get(*t)) {
 925                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
 926                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
 927                         could_hide = true;
 928                 } else if (inputs.get(*t) < in.get(*t)) {
 929                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
 930                         cannot_hide = true;
 931                 }
 932         }
 933
 934         if (could_hide && !cannot_hide) {
 935                 out = outputs + midi_bypass;
 936                 return Match (Hide, 1, hide_channels);
 937         }
 938
 939         midi_bypass.reset();
 940         return Match (Impossible, 0);
 941 }
 942
 943 XMLNode&
 944 PluginInsert::get_state ()
 945 {
 946         return state (true);
 947 }
 948
 949 XMLNode&
 950 PluginInsert::state (bool full)
 951 {
 952         XMLNode& node = Processor::state (full);
 953
 954         node.add_property("type", _plugins[0]->state_node_name());
 955         node.add_property("unique-id", _plugins[0]->unique_id());
 956         node.add_property("count", string_compose("%1", _plugins.size()));
 957
 958         /* remember actual i/o configuration (for later placeholder
 959          * in case the plugin goes missing) */
 960         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
 961         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
 962
 963         _plugins[0]->set_insert_id(this->id());
 964         node.add_child_nocopy (_plugins[0]->get_state());
 965
 966         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
 967                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
 968                 if (ac) {
 969                         node.add_child_nocopy (ac->get_state());
 970                 }
 971         }
 972
 973         return node;
 974 }
 975
 976 void
 977 PluginInsert::set_control_ids (const XMLNode& node, int version)
 978 {
 979         const XMLNodeList& nlist = node.children();
 980         XMLNodeConstIterator iter;
 981         set<Evoral::Parameter>::const_iterator p;
 982
 983         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
 984                 if ((*iter)->name() == Controllable::xml_node_name) {
 985                         const XMLProperty* prop;
 986
 987                         uint32_t p = (uint32_t)-1;
 988 #ifdef LV2_SUPPORT
 989                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
 990                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
 991                                 if (lv2plugin) {
 992                                         p = lv2plugin->port_index(prop->value().c_str());
 993                                 }
 994                         }
 995 #endif
 996                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
 997                                 p = atoi (prop->value());
 998                         }
 999
1000                         if (p != (uint32_t)-1) {
1001
1002                                 /* this may create the new controllable */
1003
1004                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1005
1006 #ifndef NO_PLUGIN_STATE
1007                                 if (!c) {
1008                                         continue;
1009                                 }
1010                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1011                                 if (ac) {
1012                                         ac->set_state (**iter, version);
1013                                 }
1014 #endif
1015                         }
1016                 }
1017         }
1018 }
1019
1020 int
1021 PluginInsert::set_state(const XMLNode& node, int version)
1022 {
1023         XMLNodeList nlist = node.children();
1024         XMLNodeIterator niter;
1025         XMLPropertyList plist;
1026         const XMLProperty *prop;
1027         ARDOUR::PluginType type;
1028
1029         if ((prop = node.property ("type")) == 0) {
1030                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1031                 return -1;
1032         }
1033
1034         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1035                 type = ARDOUR::LADSPA;
1036         } else if (prop->value() == X_("lv2")) {
1037                 type = ARDOUR::LV2;
1038         } else if (prop->value() == X_("windows-vst")) {
1039                 type = ARDOUR::Windows_VST;
1040         } else if (prop->value() == X_("lxvst")) {
1041                 type = ARDOUR::LXVST;
1042         } else if (prop->value() == X_("audiounit")) {
1043                 type = ARDOUR::AudioUnit;
1044         } else if (prop->value() == X_("luaproc")) {
1045                 type = ARDOUR::Lua;
1046         } else {
1047                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1048                                   prop->value())
1049                       << endmsg;
1050                 return -1;
1051         }
1052
1053         prop = node.property ("unique-id");
1054
1055         if (prop == 0) {
1056 #ifdef WINDOWS_VST_SUPPORT
1057                 /* older sessions contain VST plugins with only an "id" field.
1058                  */
1059
1060                 if (type == ARDOUR::Windows_VST) {
1061                         prop = node.property ("id");
1062                 }
1063 #endif
1064
1065 #ifdef LXVST_SUPPORT
1066                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1067
1068                 if (type == ARDOUR::LXVST) {
1069                         prop = node.property ("id");
1070                 }
1071 #endif
1072                 /* recheck  */
1073
1074                 if (prop == 0) {
1075                         error << _("Plugin has no unique ID field") << endmsg;
1076                         return -1;
1077                 }
1078         }
1079
1080         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1081
1082         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1083          * allow to move sessions windows <> linux */
1084 #ifdef LXVST_SUPPORT
1085         if (plugin == 0 && type == ARDOUR::Windows_VST) {
1086                 type = ARDOUR::LXVST;
1087                 plugin = find_plugin (_session, prop->value(), type);
1088         }
1089 #endif
1090
1091 #ifdef WINDOWS_VST_SUPPORT
1092         if (plugin == 0 && type == ARDOUR::LXVST) {
1093                 type = ARDOUR::Windows_VST;
1094                 plugin = find_plugin (_session, prop->value(), type);
1095         }
1096 #endif
1097
1098         if (plugin == 0) {
1099                 error << string_compose(
1100                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1101                           "Perhaps it was removed or moved since it was last used."),
1102                         prop->value())
1103                       << endmsg;
1104                 return -1;
1105         }
1106
1107         if (type == ARDOUR::Lua) {
1108                 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1109                 // we need to load the script to set the name and parameters.
1110                 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1111                 if (ls && lp) {
1112                         lp->set_script_from_state (*ls);
1113                 }
1114         }
1115
1116         // The name of the PluginInsert comes from the plugin, nothing else
1117         _name = plugin->get_info()->name;
1118
1119         uint32_t count = 1;
1120
1121         // Processor::set_state() will set this, but too late
1122         // for it to be available when setting up plugin
1123         // state. We can't call Processor::set_state() until
1124         // the plugins themselves are created and added.
1125
1126         set_id (node);
1127
1128         if (_plugins.empty()) {
1129                 /* if we are adding the first plugin, we will need to set
1130                    up automatable controls.
1131                 */
1132                 add_plugin (plugin);
1133                 create_automatable_parameters ();
1134                 set_control_ids (node, version);
1135         }
1136
1137         if ((prop = node.property ("count")) != 0) {
1138                 sscanf (prop->value().c_str(), "%u", &count);
1139         }
1140
1141         if (_plugins.size() != count) {
1142                 for (uint32_t n = 1; n < count; ++n) {
1143                         add_plugin (plugin_factory (plugin));
1144                 }
1145         }
1146
1147         Processor::set_state (node, version);
1148
1149         PBD::ID new_id = this->id();
1150         PBD::ID old_id = this->id();
1151
1152         if ((prop = node.property ("id")) != 0) {
1153                 old_id = prop->value ();
1154         }
1155
1156         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1157
1158                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1159                    and set all plugins to the same state.
1160                 */
1161
1162                 if ((*niter)->name() == plugin->state_node_name()) {
1163
1164                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1165                                 /* Plugin state can include external files which are named after the ID.
1166                                  *
1167                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
1168                                  * been changed, so we need to use the old ID from the XML to load the
1169                                  * state and then update the ID.
1170                                  *
1171                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
1172                                  * but we need to call set_insert_id() to clear the cached plugin-state
1173                                  * and force a change.
1174                                  */
1175                                 if (!regenerate_xml_or_string_ids ()) {
1176                                         (*i)->set_insert_id (new_id);
1177                                 } else {
1178                                         (*i)->set_insert_id (old_id);
1179                                 }
1180
1181                                 (*i)->set_state (**niter, version);
1182
1183                                 if (regenerate_xml_or_string_ids ()) {
1184                                         (*i)->set_insert_id (new_id);
1185                                 }
1186                         }
1187
1188                         break;
1189                 }
1190         }
1191
1192         if (version < 3000) {
1193
1194                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1195                    this is all handled by Automatable
1196                 */
1197
1198                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1199                         if ((*niter)->name() == "Redirect") {
1200                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1201                                 Processor::set_state (**niter, version);
1202                                 break;
1203                         }
1204                 }
1205
1206                 set_parameter_state_2X (node, version);
1207         }
1208
1209         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1210                 if (active()) {
1211                         (*i)->activate ();
1212                 } else {
1213                         (*i)->deactivate ();
1214                 }
1215         }
1216
1217         return 0;
1218 }
1219
1220 void
1221 PluginInsert::update_id (PBD::ID id)
1222 {
1223         set_id (id.to_s());
1224         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1225                 (*i)->set_insert_id (id);
1226         }
1227 }
1228
1229 void
1230 PluginInsert::set_state_dir (const std::string& d)
1231 {
1232         // state() only saves the state of the first plugin
1233         _plugins[0]->set_state_dir (d);
1234 }
1235
1236 void
1237 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1238 {
1239         XMLNodeList nlist = node.children();
1240         XMLNodeIterator niter;
1241
1242         /* look for port automation node */
1243
1244         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1245
1246                 if ((*niter)->name() != port_automation_node_name) {
1247                         continue;
1248                 }
1249
1250                 XMLNodeList cnodes;
1251                 XMLProperty *cprop;
1252                 XMLNodeConstIterator iter;
1253                 XMLNode *child;
1254                 const char *port;
1255                 uint32_t port_id;
1256
1257                 cnodes = (*niter)->children ("port");
1258
1259                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1260
1261                         child = *iter;
1262
1263                         if ((cprop = child->property("number")) != 0) {
1264                                 port = cprop->value().c_str();
1265                         } else {
1266                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1267                                 continue;
1268                         }
1269
1270                         sscanf (port, "%" PRIu32, &port_id);
1271
1272                         if (port_id >= _plugins[0]->parameter_count()) {
1273                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1274                                 continue;
1275                         }
1276
1277                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1278                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1279
1280                         if (c && c->alist()) {
1281                                 if (!child->children().empty()) {
1282                                         c->alist()->set_state (*child->children().front(), version);
1283
1284                                         /* In some cases 2.X saves lists with min_yval and max_yval
1285                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
1286                                            in A3 because these min/max values are used to compute
1287                                            where GUI control points should be drawn.  If we see such
1288                                            values, `correct' them to the min/max of the appropriate
1289                                            parameter.
1290                                         */
1291
1292                                         float min_y = c->alist()->get_min_y ();
1293                                         float max_y = c->alist()->get_max_y ();
1294
1295                                         ParameterDescriptor desc;
1296                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
1297
1298                                         if (min_y == FLT_MIN) {
1299                                                 min_y = desc.lower;
1300                                         }
1301
1302                                         if (max_y == FLT_MAX) {
1303                                                 max_y = desc.upper;
1304                                         }
1305
1306                                         c->alist()->set_yrange (min_y, max_y);
1307                                 }
1308                         } else {
1309                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1310                         }
1311                 }
1312
1313                 /* done */
1314
1315                 break;
1316         }
1317 }
1318
1319
1320 string
1321 PluginInsert::describe_parameter (Evoral::Parameter param)
1322 {
1323         if (param.type() == PluginAutomation) {
1324                 return _plugins[0]->describe_parameter (param);
1325         } else if (param.type() == PluginPropertyAutomation) {
1326                 boost::shared_ptr<AutomationControl> c(automation_control(param));
1327                 if (c && !c->desc().label.empty()) {
1328                         return c->desc().label;
1329                 }
1330         }
1331         return Automatable::describe_parameter(param);
1332 }
1333
1334 ARDOUR::framecnt_t
1335 PluginInsert::signal_latency() const
1336 {
1337         if (_user_latency) {
1338                 return _user_latency;
1339         }
1340
1341         return _plugins[0]->signal_latency ();
1342 }
1343
1344 ARDOUR::PluginType
1345 PluginInsert::type ()
1346 {
1347        return plugin()->get_info()->type;
1348 }
1349
1350 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
1351                                             const Evoral::Parameter&          param,
1352                                             const ParameterDescriptor&        desc,
1353                                             boost::shared_ptr<AutomationList> list)
1354         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1355         , _plugin (p)
1356 {
1357         if (alist()) {
1358                 alist()->reset_default (desc.normal);
1359                 if (desc.toggled) {
1360                         list->set_interpolation(Evoral::ControlList::Discrete);
1361                 }
1362         }
1363
1364         if (desc.toggled) {
1365                 set_flags(Controllable::Toggle);
1366         }
1367 }
1368
1369 /** @param val `user' value */
1370 void
1371 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1372 {
1373         if (writable()) {
1374                 _set_value (user_val, group_override);
1375         }
1376 }
1377 void
1378 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1379 {
1380         /* used only by automation playback */
1381         _set_value (user_val, Controllable::NoGroup);
1382 }
1383
1384 void
1385 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1386 {
1387         /* FIXME: probably should be taking out some lock here.. */
1388
1389         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1390                 (*i)->set_parameter (_list->parameter().id(), user_val);
1391         }
1392
1393         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1394         if (iasp) {
1395                 iasp->set_parameter (_list->parameter().id(), user_val);
1396         }
1397
1398         AutomationControl::set_value (user_val, group_override);
1399 }
1400
1401 void
1402 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1403 {
1404         AutomationControl::set_value (user_val, Controllable::NoGroup);
1405 }
1406
1407 XMLNode&
1408 PluginInsert::PluginControl::get_state ()
1409 {
1410         stringstream ss;
1411
1412         XMLNode& node (AutomationControl::get_state());
1413         ss << parameter().id();
1414         node.add_property (X_("parameter"), ss.str());
1415 #ifdef LV2_SUPPORT
1416         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1417         if (lv2plugin) {
1418                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1419         }
1420 #endif
1421
1422         return node;
1423 }
1424
1425 /** @return `user' val */
1426 double
1427 PluginInsert::PluginControl::get_value () const
1428 {
1429         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1430
1431         if (!plugin) {
1432                 return 0.0;
1433         }
1434
1435         return plugin->get_parameter (_list->parameter().id());
1436 }
1437
1438 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
1439                                                             const Evoral::Parameter&          param,
1440                                                             const ParameterDescriptor&        desc,
1441                                                             boost::shared_ptr<AutomationList> list)
1442         : AutomationControl (p->session(), param, desc, list)
1443         , _plugin (p)
1444 {
1445         if (alist()) {
1446                 alist()->set_yrange (desc.lower, desc.upper);
1447                 alist()->reset_default (desc.normal);
1448         }
1449
1450         if (desc.toggled) {
1451                 set_flags(Controllable::Toggle);
1452         }
1453 }
1454
1455 void
1456 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1457 {
1458         if (writable()) {
1459                 set_value_unchecked (user_val);
1460         }
1461 }
1462
1463 void
1464 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1465 {
1466         /* Old numeric set_value(), coerce to appropriate datatype if possible.
1467            This is lossy, but better than nothing until Ardour's automation system
1468            can handle various datatypes all the way down. */
1469         const Variant value(_desc.datatype, user_val);
1470         if (value.type() == Variant::NOTHING) {
1471                 error << "set_value(double) called for non-numeric property" << endmsg;
1472                 return;
1473         }
1474
1475         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1476                 (*i)->set_property(_list->parameter().id(), value);
1477         }
1478
1479         _value = value;
1480         AutomationControl::set_value (user_val, Controllable::NoGroup);
1481 }
1482
1483 XMLNode&
1484 PluginInsert::PluginPropertyControl::get_state ()
1485 {
1486         stringstream ss;
1487
1488         XMLNode& node (AutomationControl::get_state());
1489         ss << parameter().id();
1490         node.add_property (X_("property"), ss.str());
1491         node.remove_property (X_("value"));
1492
1493         return node;
1494 }
1495
1496 double
1497 PluginInsert::PluginPropertyControl::get_value () const
1498 {
1499         return _value.to_double();
1500 }
1501
1502 boost::shared_ptr<Plugin>
1503 PluginInsert::get_impulse_analysis_plugin()
1504 {
1505         boost::shared_ptr<Plugin> ret;
1506         if (_impulseAnalysisPlugin.expired()) {
1507                 ret = plugin_factory(_plugins[0]);
1508                 ret->configure_io (input_streams (), output_streams ());
1509                 _impulseAnalysisPlugin = ret;
1510         } else {
1511                 ret = _impulseAnalysisPlugin.lock();
1512         }
1513
1514         return ret;
1515 }
1516
1517 void
1518 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1519 {
1520         // called from outside the audio thread, so this should be safe
1521         // only do audio as analysis is (currently) only for audio plugins
1522         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, input_streams().n_audio(),  nframes);
1523         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1524
1525         _signal_analysis_collected_nframes   = 0;
1526         _signal_analysis_collect_nframes_max = nframes;
1527 }
1528
1529 /** Add a plugin to our list */
1530 void
1531 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1532 {
1533         plugin->set_insert_id (this->id());
1534
1535         if (_plugins.empty()) {
1536                 /* first (and probably only) plugin instance - connect to relevant signals
1537                  */
1538
1539                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1540                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1541                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1542         }
1543
1544         _plugins.push_back (plugin);
1545 }
1546
1547 void
1548 PluginInsert::realtime_handle_transport_stopped ()
1549 {
1550         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1551                 (*i)->realtime_handle_transport_stopped ();
1552         }
1553 }
1554
1555 void
1556 PluginInsert::realtime_locate ()
1557 {
1558         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1559                 (*i)->realtime_locate ();
1560         }
1561 }
1562
1563 void
1564 PluginInsert::monitoring_changed ()
1565 {
1566         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1567                 (*i)->monitoring_changed ();
1568         }
1569 }
1570
1571 void
1572 PluginInsert::start_touch (uint32_t param_id)
1573 {
1574         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1575         if (ac) {
1576                 ac->start_touch (session().audible_frame());
1577         }
1578 }
1579
1580 void
1581 PluginInsert::end_touch (uint32_t param_id)
1582 {
1583         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1584         if (ac) {
1585                 ac->stop_touch (true, session().audible_frame());
1586         }
1587 }