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