libs/ardour/plugin_insert.cc

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