libs/ardour/plugin_insert.cc

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