libs/ardour/plugin_insert.cc

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