libs/ardour/plugin_insert.cc

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