libs/ardour/plugin_insert.cc

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