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                 if ((*i)->connect_and_run(bufs, in_map, out_map, nframes, offset)) {
 443                         deactivate ();
 444                 }
 445                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 446                         in_map.offset_to(*t, natural_input_streams().get(*t));
 447                         out_map.offset_to(*t, natural_output_streams().get(*t));
 448                 }
 449         }
 450
 451         if (collect_signal_nframes > 0) {
 452                 // collect output
 453                 //std::cerr << "       output, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 454                 //std::cerr << "               streams " << output_streams().n_audio() << std::endl;
 455
 456                 _signal_analysis_outputs.set_count(output_streams());
 457
 458                 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
 459                         _signal_analysis_outputs.get_audio(i).read_from(
 460                                 bufs.get_audio(i),
 461                                 collect_signal_nframes,
 462                                 _signal_analysis_collected_nframes); // offset is for target buffer
 463                 }
 464
 465                 _signal_analysis_collected_nframes += collect_signal_nframes;
 466                 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
 467
 468                 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
 469                         _signal_analysis_collect_nframes_max = 0;
 470                         _signal_analysis_collected_nframes   = 0;
 471
 472                         AnalysisDataGathered(&_signal_analysis_inputs,
 473                                              &_signal_analysis_outputs);
 474                 }
 475         }
 476         /* leave remaining channel buffers alone */
 477 }
 478
 479 void
 480 PluginInsert::silence (framecnt_t nframes)
 481 {
 482         if (!active ()) {
 483                 return;
 484         }
 485
 486         ChanMapping in_map(input_streams());
 487         ChanMapping out_map(output_streams());
 488
 489         if (_match.method == Split) {
 490                 /* fix the input mapping so that we have maps for each of the plugin's inputs */
 491                 in_map = ChanMapping (natural_input_streams ());
 492         }
 493
 494         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 495                 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
 496         }
 497 }
 498
 499 void
 500 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
 501 {
 502         if (_pending_active) {
 503                 /* run as normal if we are active or moving from inactive to active */
 504
 505                 if (_session.transport_rolling() || _session.bounce_processing()) {
 506                         automation_run (bufs, start_frame, nframes);
 507                 } else {
 508                         connect_and_run (bufs, nframes, 0, false);
 509                 }
 510
 511         } else {
 512                 uint32_t in = input_streams ().n_audio ();
 513                 uint32_t out = output_streams().n_audio ();
 514
 515                 if (has_no_audio_inputs() || in == 0) {
 516
 517                         /* silence all (audio) outputs. Should really declick
 518                          * at the transitions of "active"
 519                          */
 520
 521                         for (uint32_t n = 0; n < out; ++n) {
 522                                 bufs.get_audio (n).silence (nframes);
 523                         }
 524
 525                 } else if (out > in) {
 526
 527                         /* not active, but something has make up for any channel count increase */
 528
 529                         // TODO: option round-robin (n % in) or silence additional buffers ??
 530                         // for now , simply replicate last buffer
 531                         for (uint32_t n = in; n < out; ++n) {
 532                                 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
 533                         }
 534                 }
 535
 536                 bufs.count().set_audio (out);
 537         }
 538
 539         _active = _pending_active;
 540
 541         /* we have no idea whether the plugin generated silence or not, so mark
 542          * all buffers appropriately.
 543          */
 544
 545 }
 546
 547 void
 548 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
 549 {
 550         Evoral::ControlEvent next_event (0, 0.0f);
 551         framepos_t now = start;
 552         framepos_t end = now + nframes;
 553         framecnt_t offset = 0;
 554
 555         Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
 556
 557         if (!lm.locked()) {
 558                 connect_and_run (bufs, nframes, offset, false);
 559                 return;
 560         }
 561
 562         if (!find_next_event (now, end, next_event) || requires_fixed_sized_buffers()) {
 563
 564                 /* no events have a time within the relevant range */
 565
 566                 connect_and_run (bufs, nframes, offset, true, now);
 567                 return;
 568         }
 569
 570         while (nframes) {
 571
 572                 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
 573
 574                 connect_and_run (bufs, cnt, offset, true, now);
 575
 576                 nframes -= cnt;
 577                 offset += cnt;
 578                 now += cnt;
 579
 580                 if (!find_next_event (now, end, next_event)) {
 581                         break;
 582                 }
 583         }
 584
 585         /* cleanup anything that is left to do */
 586
 587         if (nframes) {
 588                 connect_and_run (bufs, nframes, offset, true, now);
 589         }
 590 }
 591
 592 float
 593 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
 594 {
 595         if (param.type() != PluginAutomation)
 596                 return 1.0;
 597
 598         if (_plugins.empty()) {
 599                 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
 600                       << endmsg;
 601                 abort(); /*NOTREACHED*/
 602         }
 603
 604         return _plugins[0]->default_value (param.id());
 605 }
 606
 607
 608 bool
 609 PluginInsert::can_reset_all_parameters ()
 610 {
 611         bool all = true;
 612         uint32_t params = 0;
 613         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 614                 bool ok=false;
 615                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 616
 617                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 618                         continue;
 619                 }
 620
 621                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 622                 if (!ac) {
 623                         continue;
 624                 }
 625
 626                 ++params;
 627                 if (ac->automation_state() & Play) {
 628                         all = false;
 629                         break;
 630                 }
 631         }
 632         return all && (params > 0);
 633 }
 634
 635 bool
 636 PluginInsert::reset_parameters_to_default ()
 637 {
 638         bool all = true;
 639
 640         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 641                 bool ok=false;
 642                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 643
 644                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 645                         continue;
 646                 }
 647
 648                 const float dflt = _plugins[0]->default_value (cid);
 649                 const float curr = _plugins[0]->get_parameter (cid);
 650
 651                 if (dflt == curr) {
 652                         continue;
 653                 }
 654
 655                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 656                 if (!ac) {
 657                         continue;
 658                 }
 659
 660                 if (ac->automation_state() & Play) {
 661                         all = false;
 662                         continue;
 663                 }
 664
 665                 ac->set_value (dflt, Controllable::NoGroup);
 666         }
 667         return all;
 668 }
 669
 670 boost::shared_ptr<Plugin>
 671 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
 672 {
 673         boost::shared_ptr<LadspaPlugin> lp;
 674 #ifdef LV2_SUPPORT
 675         boost::shared_ptr<LV2Plugin> lv2p;
 676 #endif
 677 #ifdef WINDOWS_VST_SUPPORT
 678         boost::shared_ptr<WindowsVSTPlugin> vp;
 679 #endif
 680 #ifdef LXVST_SUPPORT
 681         boost::shared_ptr<LXVSTPlugin> lxvp;
 682 #endif
 683 #ifdef AUDIOUNIT_SUPPORT
 684         boost::shared_ptr<AUPlugin> ap;
 685 #endif
 686
 687         if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
 688                 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
 689 #ifdef LV2_SUPPORT
 690         } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
 691                 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
 692 #endif
 693 #ifdef WINDOWS_VST_SUPPORT
 694         } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
 695                 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
 696 #endif
 697 #ifdef LXVST_SUPPORT
 698         } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
 699                 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
 700 #endif
 701 #ifdef AUDIOUNIT_SUPPORT
 702         } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
 703                 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
 704 #endif
 705         }
 706
 707         fatal << string_compose (_("programming error: %1"),
 708                           X_("unknown plugin type in PluginInsert::plugin_factory"))
 709               << endmsg;
 710         abort(); /*NOTREACHED*/
 711         return boost::shared_ptr<Plugin> ((Plugin*) 0);
 712 }
 713
 714 bool
 715 PluginInsert::configure_io (ChanCount in, ChanCount out)
 716 {
 717         Match old_match = _match;
 718         ChanCount old_in = input_streams ();
 719         ChanCount old_out = output_streams ();
 720
 721         _configured_in = in;
 722         _configured_out = out;
 723
 724         /* set the matching method and number of plugins that we will use to meet this configuration */
 725         _match = private_can_support_io_configuration (in, out);
 726         if (set_count (_match.plugins) == false) {
 727                 PluginIoReConfigure (); /* EMIT SIGNAL */
 728                 return false;
 729         }
 730
 731         /* configure plugins */
 732         switch (_match.method) {
 733         case Split:
 734         case Hide:
 735                 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out) == false) {
 736                         PluginIoReConfigure (); /* EMIT SIGNAL */
 737                         return false;
 738                 }
 739                 break;
 740
 741         default:
 742                 if (_plugins.front()->configure_io (in, out) == false) {
 743                         PluginIoReConfigure (); /* EMIT SIGNAL */
 744                         return false;
 745                 }
 746                 break;
 747         }
 748
 749         if (  (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
 750                         || old_in != in
 751                         || old_out != out
 752                         )
 753         {
 754                 PluginIoReConfigure (); /* EMIT SIGNAL */
 755         }
 756
 757         // we don't know the analysis window size, so we must work with the
 758         // current buffer size here. each request for data fills in these
 759         // buffers and the analyser makes sure it gets enough data for the
 760         // analysis window
 761         session().ensure_buffer_set (_signal_analysis_inputs, in);
 762         //_signal_analysis_inputs.set_count (in);
 763
 764         session().ensure_buffer_set (_signal_analysis_outputs, out);
 765         //_signal_analysis_outputs.set_count (out);
 766
 767         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
 768
 769         return Processor::configure_io (in, out);
 770 }
 771
 772 /** Decide whether this PluginInsert can support a given IO configuration.
 773  *  To do this, we run through a set of possible solutions in rough order of
 774  *  preference.
 775  *
 776  *  @param in Required input channel count.
 777  *  @param out Filled in with the output channel count if we return true.
 778  *  @return true if the given IO configuration can be supported.
 779  */
 780 bool
 781 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 782 {
 783         return private_can_support_io_configuration (in, out).method != Impossible;
 784 }
 785
 786 /** A private version of can_support_io_configuration which returns the method
 787  *  by which the configuration can be matched, rather than just whether or not
 788  *  it can be.
 789  */
 790 PluginInsert::Match
 791 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
 792 {
 793         if (_plugins.empty()) {
 794                 return Match();
 795         }
 796
 797         PluginInfoPtr info = _plugins.front()->get_info();
 798         ChanCount in; in += inx;
 799         midi_bypass.reset();
 800
 801         if (info->reconfigurable_io()) {
 802                 /* Plugin has flexible I/O, so delegate to it */
 803                 bool const r = _plugins.front()->can_support_io_configuration (in, out);
 804                 if (!r) {
 805                         return Match (Impossible, 0);
 806                 }
 807
 808                 return Match (Delegate, 1);
 809         }
 810
 811         ChanCount inputs  = info->n_inputs;
 812         ChanCount outputs = info->n_outputs;
 813
 814         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
 815                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
 816                 midi_bypass.set(DataType::MIDI, 1);
 817         }
 818         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
 819                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
 820                 in.set(DataType::MIDI, 0);
 821         }
 822
 823         bool no_inputs = true;
 824         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 825                 if (inputs.get (*t) != 0) {
 826                         no_inputs = false;
 827                         break;
 828                 }
 829         }
 830
 831         if (no_inputs) {
 832                 /* no inputs so we can take any input configuration since we throw it away */
 833                 out = outputs + midi_bypass;
 834                 return Match (NoInputs, 1);
 835         }
 836
 837         /* Plugin inputs match requested inputs exactly */
 838         if (inputs == in) {
 839                 out = outputs + midi_bypass;
 840                 return Match (ExactMatch, 1);
 841         }
 842
 843         /* We may be able to run more than one copy of the plugin within this insert
 844            to cope with the insert having more inputs than the plugin.
 845            We allow replication only for plugins with either zero or 1 inputs and outputs
 846            for every valid data type.
 847         */
 848
 849         uint32_t f             = 0;
 850         bool     can_replicate = true;
 851         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 852
 853                 uint32_t nin = inputs.get (*t);
 854
 855                 // No inputs of this type
 856                 if (nin == 0 && in.get(*t) == 0) {
 857                         continue;
 858                 }
 859
 860                 if (nin != 1 || outputs.get (*t) != 1) {
 861                         can_replicate = false;
 862                         break;
 863                 }
 864
 865                 // Potential factor not set yet
 866                 if (f == 0) {
 867                         f = in.get(*t) / nin;
 868                 }
 869
 870                 // Factor for this type does not match another type, can not replicate
 871                 if (f != (in.get(*t) / nin)) {
 872                         can_replicate = false;
 873                         break;
 874                 }
 875         }
 876
 877         if (can_replicate) {
 878                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 879                         out.set (*t, outputs.get(*t) * f);
 880                 }
 881                 out += midi_bypass;
 882                 return Match (Replicate, f);
 883         }
 884
 885         /* If the processor has exactly one input of a given type, and
 886            the plugin has more, we can feed the single processor input
 887            to some or all of the plugin inputs.  This is rather
 888            special-case-y, but the 1-to-many case is by far the
 889            simplest.  How do I split thy 2 processor inputs to 3
 890            plugin inputs?  Let me count the ways ...
 891         */
 892
 893         bool can_split = true;
 894         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 895
 896                 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
 897                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
 898
 899                 if (!can_split_type && !nothing_to_do_for_type) {
 900                         can_split = false;
 901                 }
 902         }
 903
 904         if (can_split) {
 905                 out = outputs + midi_bypass;
 906                 return Match (Split, 1);
 907         }
 908
 909         /* If the plugin has more inputs than we want, we can `hide' some of them
 910            by feeding them silence.
 911         */
 912
 913         bool could_hide = false;
 914         bool cannot_hide = false;
 915         ChanCount hide_channels;
 916
 917         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 918                 if (inputs.get(*t) > in.get(*t)) {
 919                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
 920                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
 921                         could_hide = true;
 922                 } else if (inputs.get(*t) < in.get(*t)) {
 923                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
 924                         cannot_hide = true;
 925                 }
 926         }
 927
 928         if (could_hide && !cannot_hide) {
 929                 out = outputs + midi_bypass;
 930                 return Match (Hide, 1, hide_channels);
 931         }
 932
 933         midi_bypass.reset();
 934         return Match (Impossible, 0);
 935 }
 936
 937 XMLNode&
 938 PluginInsert::get_state ()
 939 {
 940         return state (true);
 941 }
 942
 943 XMLNode&
 944 PluginInsert::state (bool full)
 945 {
 946         XMLNode& node = Processor::state (full);
 947
 948         node.add_property("type", _plugins[0]->state_node_name());
 949         node.add_property("unique-id", _plugins[0]->unique_id());
 950         node.add_property("count", string_compose("%1", _plugins.size()));
 951
 952         /* remember actual i/o configuration (for later placeholder
 953          * in case the plugin goes missing) */
 954         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
 955         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
 956
 957         _plugins[0]->set_insert_id(this->id());
 958         node.add_child_nocopy (_plugins[0]->get_state());
 959
 960         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
 961                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
 962                 if (ac) {
 963                         node.add_child_nocopy (ac->get_state());
 964                 }
 965         }
 966
 967         return node;
 968 }
 969
 970 void
 971 PluginInsert::set_control_ids (const XMLNode& node, int version)
 972 {
 973         const XMLNodeList& nlist = node.children();
 974         XMLNodeConstIterator iter;
 975         set<Evoral::Parameter>::const_iterator p;
 976
 977         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
 978                 if ((*iter)->name() == Controllable::xml_node_name) {
 979                         const XMLProperty* prop;
 980
 981                         uint32_t p = (uint32_t)-1;
 982 #ifdef LV2_SUPPORT
 983                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
 984                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
 985                                 if (lv2plugin) {
 986                                         p = lv2plugin->port_index(prop->value().c_str());
 987                                 }
 988                         }
 989 #endif
 990                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
 991                                 p = atoi (prop->value());
 992                         }
 993
 994                         if (p != (uint32_t)-1) {
 995
 996                                 /* this may create the new controllable */
 997
 998                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
 999
1000 #ifndef NO_PLUGIN_STATE
1001                                 if (!c) {
1002                                         continue;
1003                                 }
1004                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1005                                 if (ac) {
1006                                         ac->set_state (**iter, version);
1007                                 }
1008 #endif
1009                         }
1010                 }
1011         }
1012 }
1013
1014 int
1015 PluginInsert::set_state(const XMLNode& node, int version)
1016 {
1017         XMLNodeList nlist = node.children();
1018         XMLNodeIterator niter;
1019         XMLPropertyList plist;
1020         const XMLProperty *prop;
1021         ARDOUR::PluginType type;
1022
1023         if ((prop = node.property ("type")) == 0) {
1024                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1025                 return -1;
1026         }
1027
1028         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1029                 type = ARDOUR::LADSPA;
1030         } else if (prop->value() == X_("lv2")) {
1031                 type = ARDOUR::LV2;
1032         } else if (prop->value() == X_("windows-vst")) {
1033                 type = ARDOUR::Windows_VST;
1034         } else if (prop->value() == X_("lxvst")) {
1035                 type = ARDOUR::LXVST;
1036         } else if (prop->value() == X_("audiounit")) {
1037                 type = ARDOUR::AudioUnit;
1038         } else {
1039                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1040                                   prop->value())
1041                       << endmsg;
1042                 return -1;
1043         }
1044
1045         prop = node.property ("unique-id");
1046
1047         if (prop == 0) {
1048 #ifdef WINDOWS_VST_SUPPORT
1049                 /* older sessions contain VST plugins with only an "id" field.
1050                  */
1051
1052                 if (type == ARDOUR::Windows_VST) {
1053                         prop = node.property ("id");
1054                 }
1055 #endif
1056
1057 #ifdef LXVST_SUPPORT
1058                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1059
1060                 if (type == ARDOUR::LXVST) {
1061                         prop = node.property ("id");
1062                 }
1063 #endif
1064                 /* recheck  */
1065
1066                 if (prop == 0) {
1067                         error << _("Plugin has no unique ID field") << endmsg;
1068                         return -1;
1069                 }
1070         }
1071
1072         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1073
1074         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1075          * allow to move sessions windows <> linux */
1076 #ifdef LXVST_SUPPORT
1077         if (plugin == 0 && type == ARDOUR::Windows_VST) {
1078                 type = ARDOUR::LXVST;
1079                 plugin = find_plugin (_session, prop->value(), type);
1080         }
1081 #endif
1082
1083 #ifdef WINDOWS_VST_SUPPORT
1084         if (plugin == 0 && type == ARDOUR::LXVST) {
1085                 type = ARDOUR::Windows_VST;
1086                 plugin = find_plugin (_session, prop->value(), type);
1087         }
1088 #endif
1089
1090         if (plugin == 0) {
1091                 error << string_compose(
1092                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1093                           "Perhaps it was removed or moved since it was last used."),
1094                         prop->value())
1095                       << endmsg;
1096                 return -1;
1097         }
1098
1099         // The name of the PluginInsert comes from the plugin, nothing else
1100         _name = plugin->get_info()->name;
1101
1102         uint32_t count = 1;
1103
1104         // Processor::set_state() will set this, but too late
1105         // for it to be available when setting up plugin
1106         // state. We can't call Processor::set_state() until
1107         // the plugins themselves are created and added.
1108
1109         set_id (node);
1110
1111         if (_plugins.empty()) {
1112                 /* if we are adding the first plugin, we will need to set
1113                    up automatable controls.
1114                 */
1115                 add_plugin (plugin);
1116                 create_automatable_parameters ();
1117                 set_control_ids (node, version);
1118         }
1119
1120         if ((prop = node.property ("count")) != 0) {
1121                 sscanf (prop->value().c_str(), "%u", &count);
1122         }
1123
1124         if (_plugins.size() != count) {
1125                 for (uint32_t n = 1; n < count; ++n) {
1126                         add_plugin (plugin_factory (plugin));
1127                 }
1128         }
1129
1130         Processor::set_state (node, version);
1131
1132         PBD::ID new_id = this->id();
1133         PBD::ID old_id = this->id();
1134
1135         if ((prop = node.property ("id")) != 0) {
1136                 old_id = prop->value ();
1137         }
1138
1139         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1140
1141                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1142                    and set all plugins to the same state.
1143                 */
1144
1145                 if ((*niter)->name() == plugin->state_node_name()) {
1146
1147                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1148                                 /* Plugin state can include external files which are named after the ID.
1149                                  *
1150                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
1151                                  * been changed, so we need to use the old ID from the XML to load the
1152                                  * state and then update the ID.
1153                                  *
1154                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
1155                                  * but we need to call set_insert_id() to clear the cached plugin-state
1156                                  * and force a change.
1157                                  */
1158                                 if (!regenerate_xml_or_string_ids ()) {
1159                                         (*i)->set_insert_id (new_id);
1160                                 } else {
1161                                         (*i)->set_insert_id (old_id);
1162                                 }
1163
1164                                 (*i)->set_state (**niter, version);
1165
1166                                 if (regenerate_xml_or_string_ids ()) {
1167                                         (*i)->set_insert_id (new_id);
1168                                 }
1169                         }
1170
1171                         break;
1172                 }
1173         }
1174
1175         if (version < 3000) {
1176
1177                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1178                    this is all handled by Automatable
1179                 */
1180
1181                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1182                         if ((*niter)->name() == "Redirect") {
1183                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1184                                 Processor::set_state (**niter, version);
1185                                 break;
1186                         }
1187                 }
1188
1189                 set_parameter_state_2X (node, version);
1190         }
1191
1192         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1193                 if (active()) {
1194                         (*i)->activate ();
1195                 } else {
1196                         (*i)->deactivate ();
1197                 }
1198         }
1199
1200         return 0;
1201 }
1202
1203 void
1204 PluginInsert::update_id (PBD::ID id)
1205 {
1206         set_id (id.to_s());
1207         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1208                 (*i)->set_insert_id (id);
1209         }
1210 }
1211
1212 void
1213 PluginInsert::set_state_dir (const std::string& d)
1214 {
1215         // state() only saves the state of the first plugin
1216         _plugins[0]->set_state_dir (d);
1217 }
1218
1219 void
1220 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1221 {
1222         XMLNodeList nlist = node.children();
1223         XMLNodeIterator niter;
1224
1225         /* look for port automation node */
1226
1227         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1228
1229                 if ((*niter)->name() != port_automation_node_name) {
1230                         continue;
1231                 }
1232
1233                 XMLNodeList cnodes;
1234                 XMLProperty *cprop;
1235                 XMLNodeConstIterator iter;
1236                 XMLNode *child;
1237                 const char *port;
1238                 uint32_t port_id;
1239
1240                 cnodes = (*niter)->children ("port");
1241
1242                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1243
1244                         child = *iter;
1245
1246                         if ((cprop = child->property("number")) != 0) {
1247                                 port = cprop->value().c_str();
1248                         } else {
1249                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1250                                 continue;
1251                         }
1252
1253                         sscanf (port, "%" PRIu32, &port_id);
1254
1255                         if (port_id >= _plugins[0]->parameter_count()) {
1256                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1257                                 continue;
1258                         }
1259
1260                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1261                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1262
1263                         if (c && c->alist()) {
1264                                 if (!child->children().empty()) {
1265                                         c->alist()->set_state (*child->children().front(), version);
1266
1267                                         /* In some cases 2.X saves lists with min_yval and max_yval
1268                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
1269                                            in A3 because these min/max values are used to compute
1270                                            where GUI control points should be drawn.  If we see such
1271                                            values, `correct' them to the min/max of the appropriate
1272                                            parameter.
1273                                         */
1274
1275                                         float min_y = c->alist()->get_min_y ();
1276                                         float max_y = c->alist()->get_max_y ();
1277
1278                                         ParameterDescriptor desc;
1279                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
1280
1281                                         if (min_y == FLT_MIN) {
1282                                                 min_y = desc.lower;
1283                                         }
1284
1285                                         if (max_y == FLT_MAX) {
1286                                                 max_y = desc.upper;
1287                                         }
1288
1289                                         c->alist()->set_yrange (min_y, max_y);
1290                                 }
1291                         } else {
1292                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1293                         }
1294                 }
1295
1296                 /* done */
1297
1298                 break;
1299         }
1300 }
1301
1302
1303 string
1304 PluginInsert::describe_parameter (Evoral::Parameter param)
1305 {
1306         if (param.type() == PluginAutomation) {
1307                 return _plugins[0]->describe_parameter (param);
1308         } else if (param.type() == PluginPropertyAutomation) {
1309                 boost::shared_ptr<AutomationControl> c(automation_control(param));
1310                 if (c && !c->desc().label.empty()) {
1311                         return c->desc().label;
1312                 }
1313         }
1314         return Automatable::describe_parameter(param);
1315 }
1316
1317 ARDOUR::framecnt_t
1318 PluginInsert::signal_latency() const
1319 {
1320         if (_user_latency) {
1321                 return _user_latency;
1322         }
1323
1324         return _plugins[0]->signal_latency ();
1325 }
1326
1327 ARDOUR::PluginType
1328 PluginInsert::type ()
1329 {
1330        return plugin()->get_info()->type;
1331 }
1332
1333 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
1334                                             const Evoral::Parameter&          param,
1335                                             const ParameterDescriptor&        desc,
1336                                             boost::shared_ptr<AutomationList> list)
1337         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1338         , _plugin (p)
1339 {
1340         if (alist()) {
1341                 alist()->reset_default (desc.normal);
1342                 if (desc.toggled) {
1343                         list->set_interpolation(Evoral::ControlList::Discrete);
1344                 }
1345         }
1346
1347         if (desc.toggled) {
1348                 set_flags(Controllable::Toggle);
1349         }
1350 }
1351
1352 /** @param val `user' value */
1353 void
1354 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1355 {
1356         if (writable()) {
1357                 _set_value (user_val, group_override);
1358         }
1359 }
1360 void
1361 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1362 {
1363         /* used only by automation playback */
1364         _set_value (user_val, Controllable::NoGroup);
1365 }
1366
1367 void
1368 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1369 {
1370         /* FIXME: probably should be taking out some lock here.. */
1371
1372         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1373                 (*i)->set_parameter (_list->parameter().id(), user_val);
1374         }
1375
1376         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1377         if (iasp) {
1378                 iasp->set_parameter (_list->parameter().id(), user_val);
1379         }
1380
1381         AutomationControl::set_value (user_val, group_override);
1382 }
1383
1384 void
1385 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1386 {
1387         AutomationControl::set_value (user_val, Controllable::NoGroup);
1388 }
1389
1390 XMLNode&
1391 PluginInsert::PluginControl::get_state ()
1392 {
1393         stringstream ss;
1394
1395         XMLNode& node (AutomationControl::get_state());
1396         ss << parameter().id();
1397         node.add_property (X_("parameter"), ss.str());
1398 #ifdef LV2_SUPPORT
1399         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1400         if (lv2plugin) {
1401                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1402         }
1403 #endif
1404
1405         return node;
1406 }
1407
1408 /** @return `user' val */
1409 double
1410 PluginInsert::PluginControl::get_value () const
1411 {
1412         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1413
1414         if (!plugin) {
1415                 return 0.0;
1416         }
1417
1418         return plugin->get_parameter (_list->parameter().id());
1419 }
1420
1421 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
1422                                                             const Evoral::Parameter&          param,
1423                                                             const ParameterDescriptor&        desc,
1424                                                             boost::shared_ptr<AutomationList> list)
1425         : AutomationControl (p->session(), param, desc, list)
1426         , _plugin (p)
1427 {
1428         if (alist()) {
1429                 alist()->set_yrange (desc.lower, desc.upper);
1430                 alist()->reset_default (desc.normal);
1431         }
1432
1433         if (desc.toggled) {
1434                 set_flags(Controllable::Toggle);
1435         }
1436 }
1437
1438 void
1439 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1440 {
1441         if (writable()) {
1442                 set_value_unchecked (user_val);
1443         }
1444 }
1445
1446 void
1447 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1448 {
1449         /* Old numeric set_value(), coerce to appropriate datatype if possible.
1450            This is lossy, but better than nothing until Ardour's automation system
1451            can handle various datatypes all the way down. */
1452         const Variant value(_desc.datatype, user_val);
1453         if (value.type() == Variant::NOTHING) {
1454                 error << "set_value(double) called for non-numeric property" << endmsg;
1455                 return;
1456         }
1457
1458         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1459                 (*i)->set_property(_list->parameter().id(), value);
1460         }
1461
1462         _value = value;
1463         AutomationControl::set_value (user_val, Controllable::NoGroup);
1464 }
1465
1466 XMLNode&
1467 PluginInsert::PluginPropertyControl::get_state ()
1468 {
1469         stringstream ss;
1470
1471         XMLNode& node (AutomationControl::get_state());
1472         ss << parameter().id();
1473         node.add_property (X_("property"), ss.str());
1474         node.remove_property (X_("value"));
1475
1476         return node;
1477 }
1478
1479 double
1480 PluginInsert::PluginPropertyControl::get_value () const
1481 {
1482         return _value.to_double();
1483 }
1484
1485 boost::shared_ptr<Plugin>
1486 PluginInsert::get_impulse_analysis_plugin()
1487 {
1488         boost::shared_ptr<Plugin> ret;
1489         if (_impulseAnalysisPlugin.expired()) {
1490                 ret = plugin_factory(_plugins[0]);
1491                 ret->configure_io (input_streams (), output_streams ());
1492                 _impulseAnalysisPlugin = ret;
1493         } else {
1494                 ret = _impulseAnalysisPlugin.lock();
1495         }
1496
1497         return ret;
1498 }
1499
1500 void
1501 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1502 {
1503         // called from outside the audio thread, so this should be safe
1504         // only do audio as analysis is (currently) only for audio plugins
1505         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, input_streams().n_audio(),  nframes);
1506         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1507
1508         _signal_analysis_collected_nframes   = 0;
1509         _signal_analysis_collect_nframes_max = nframes;
1510 }
1511
1512 /** Add a plugin to our list */
1513 void
1514 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1515 {
1516         plugin->set_insert_id (this->id());
1517
1518         if (_plugins.empty()) {
1519                 /* first (and probably only) plugin instance - connect to relevant signals
1520                  */
1521
1522                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1523                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1524                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1525         }
1526
1527         _plugins.push_back (plugin);
1528 }
1529
1530 void
1531 PluginInsert::realtime_handle_transport_stopped ()
1532 {
1533         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1534                 (*i)->realtime_handle_transport_stopped ();
1535         }
1536 }
1537
1538 void
1539 PluginInsert::realtime_locate ()
1540 {
1541         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1542                 (*i)->realtime_locate ();
1543         }
1544 }
1545
1546 void
1547 PluginInsert::monitoring_changed ()
1548 {
1549         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1550                 (*i)->monitoring_changed ();
1551         }
1552 }
1553
1554 void
1555 PluginInsert::start_touch (uint32_t param_id)
1556 {
1557         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1558         if (ac) {
1559                 ac->start_touch (session().audible_frame());
1560         }
1561 }
1562
1563 void
1564 PluginInsert::end_touch (uint32_t param_id)
1565 {
1566         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1567         if (ac) {
1568                 ac->stop_touch (true, session().audible_frame());
1569         }
1570 }