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                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1050                                 (*i)->set_state (**niter, version);
1051                         }
1052
1053                         break;
1054                 }
1055         }
1056
1057         if (version < 3000) {
1058
1059                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1060                    this is all handled by Automatable
1061                 */
1062
1063                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1064                         if ((*niter)->name() == "Redirect") {
1065                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1066                                 Processor::set_state (**niter, version);
1067                                 break;
1068                         }
1069                 }
1070
1071                 set_parameter_state_2X (node, version);
1072         }
1073
1074         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1075                 if (active()) {
1076                         (*i)->activate ();
1077                 } else {
1078                         (*i)->deactivate ();
1079                 }
1080         }
1081
1082         return 0;
1083 }
1084
1085 void
1086 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1087 {
1088         XMLNodeList nlist = node.children();
1089         XMLNodeIterator niter;
1090
1091         /* look for port automation node */
1092
1093         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1094
1095                 if ((*niter)->name() != port_automation_node_name) {
1096                         continue;
1097                 }
1098
1099                 XMLNodeList cnodes;
1100                 XMLProperty *cprop;
1101                 XMLNodeConstIterator iter;
1102                 XMLNode *child;
1103                 const char *port;
1104                 uint32_t port_id;
1105
1106                 cnodes = (*niter)->children ("port");
1107
1108                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1109
1110                         child = *iter;
1111
1112                         if ((cprop = child->property("number")) != 0) {
1113                                 port = cprop->value().c_str();
1114                         } else {
1115                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1116                                 continue;
1117                         }
1118
1119                         sscanf (port, "%" PRIu32, &port_id);
1120
1121                         if (port_id >= _plugins[0]->parameter_count()) {
1122                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1123                                 continue;
1124                         }
1125
1126                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1127                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1128
1129                         if (c) {
1130                                 if (!child->children().empty()) {
1131                                         c->alist()->set_state (*child->children().front(), version);
1132
1133                                         /* In some cases 2.X saves lists with min_yval and max_yval
1134                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
1135                                            in A3 because these min/max values are used to compute
1136                                            where GUI control points should be drawn.  If we see such
1137                                            values, `correct' them to the min/max of the appropriate
1138                                            parameter.
1139                                         */
1140
1141                                         float min_y = c->alist()->get_min_y ();
1142                                         float max_y = c->alist()->get_max_y ();
1143
1144                                         ParameterDescriptor desc;
1145                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
1146
1147                                         if (min_y == FLT_MIN) {
1148                                                 min_y = desc.lower;
1149                                         }
1150
1151                                         if (max_y == FLT_MAX) {
1152                                                 max_y = desc.upper;
1153                                         }
1154
1155                                         c->alist()->set_yrange (min_y, max_y);
1156                                 }
1157                         } else {
1158                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1159                         }
1160                 }
1161
1162                 /* done */
1163
1164                 break;
1165         }
1166 }
1167
1168
1169 string
1170 PluginInsert::describe_parameter (Evoral::Parameter param)
1171 {
1172         if (param.type() == PluginAutomation) {
1173                 return _plugins[0]->describe_parameter (param);
1174         } else if (param.type() == PluginPropertyAutomation) {
1175                 boost::shared_ptr<AutomationControl> c(automation_control(param));
1176                 if (c && !c->desc().label.empty()) {
1177                         return c->desc().label;
1178                 }
1179         }
1180         return Automatable::describe_parameter(param);
1181 }
1182
1183 ARDOUR::framecnt_t
1184 PluginInsert::signal_latency() const
1185 {
1186         if (_user_latency) {
1187                 return _user_latency;
1188         }
1189
1190         return _plugins[0]->signal_latency ();
1191 }
1192
1193 ARDOUR::PluginType
1194 PluginInsert::type ()
1195 {
1196        return plugin()->get_info()->type;
1197 }
1198
1199 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
1200                                             const Evoral::Parameter&          param,
1201                                             const ParameterDescriptor&        desc,
1202                                             boost::shared_ptr<AutomationList> list)
1203         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1204         , _plugin (p)
1205 {
1206         if (alist()) {
1207                 alist()->reset_default (desc.normal);
1208                 if (desc.toggled) {
1209                         list->set_interpolation(Evoral::ControlList::Discrete);
1210                 }
1211         }
1212
1213         if (desc.toggled) {
1214                 set_flags(Controllable::Toggle);
1215         }
1216 }
1217
1218 /** @param val `user' value */
1219 void
1220 PluginInsert::PluginControl::set_value (double user_val)
1221 {
1222         /* FIXME: probably should be taking out some lock here.. */
1223
1224         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1225                 (*i)->set_parameter (_list->parameter().id(), user_val);
1226         }
1227
1228         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1229         if (iasp) {
1230                 iasp->set_parameter (_list->parameter().id(), user_val);
1231         }
1232
1233         AutomationControl::set_value (user_val);
1234 }
1235
1236 double
1237 PluginInsert::PluginControl::internal_to_interface (double val) const
1238 {
1239         val = Controllable::internal_to_interface(val);
1240
1241         if (_desc.logarithmic) {
1242                 if (val > 0) {
1243                         val = pow (val, 1/1.5);
1244                 } else {
1245                         val = 0;
1246                 }
1247         }
1248
1249         return val;
1250 }
1251
1252 double
1253 PluginInsert::PluginControl::interface_to_internal (double val) const
1254 {
1255         if (_desc.logarithmic) {
1256                 if (val <= 0) {
1257                         val = 0;
1258                 } else {
1259                         val = pow (val, 1.5);
1260                 }
1261         }
1262
1263         val = Controllable::interface_to_internal(val);
1264
1265         return val;
1266 }
1267
1268 XMLNode&
1269 PluginInsert::PluginControl::get_state ()
1270 {
1271         stringstream ss;
1272
1273         XMLNode& node (AutomationControl::get_state());
1274         ss << parameter().id();
1275         node.add_property (X_("parameter"), ss.str());
1276
1277         return node;
1278 }
1279
1280 /** @return `user' val */
1281 double
1282 PluginInsert::PluginControl::get_value () const
1283 {
1284         /* FIXME: probably should be taking out some lock here.. */
1285         return _plugin->get_parameter (_list->parameter());
1286 }
1287
1288 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
1289                                                             const Evoral::Parameter&          param,
1290                                                             const ParameterDescriptor&        desc,
1291                                                             boost::shared_ptr<AutomationList> list)
1292         : AutomationControl (p->session(), param, desc, list)
1293         , _plugin (p)
1294 {
1295         if (alist()) {
1296                 alist()->set_yrange (desc.lower, desc.upper);
1297                 alist()->reset_default (desc.normal);
1298         }
1299
1300         if (desc.toggled) {
1301                 set_flags(Controllable::Toggle);
1302         }
1303 }
1304
1305 void
1306 PluginInsert::PluginPropertyControl::set_value (double user_val)
1307 {
1308         /* Old numeric set_value(), coerce to appropriate datatype if possible.
1309            This is lossy, but better than nothing until Ardour's automation system
1310            can handle various datatypes all the way down. */
1311         const Variant value(_desc.datatype, user_val);
1312         if (value.type() == Variant::NOTHING) {
1313                 error << "set_value(double) called for non-numeric property" << endmsg;
1314                 return;
1315         }
1316
1317         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1318                 (*i)->set_property(_list->parameter().id(), value);
1319         }
1320
1321         _value = value;
1322         AutomationControl::set_value(user_val);
1323 }
1324
1325 XMLNode&
1326 PluginInsert::PluginPropertyControl::get_state ()
1327 {
1328         stringstream ss;
1329
1330         XMLNode& node (AutomationControl::get_state());
1331         ss << parameter().id();
1332         node.add_property (X_("property"), ss.str());
1333         node.remove_property (X_("value"));
1334
1335         return node;
1336 }
1337
1338 double
1339 PluginInsert::PluginPropertyControl::get_value () const
1340 {
1341         return _value.to_double();
1342 }
1343
1344 boost::shared_ptr<Plugin>
1345 PluginInsert::get_impulse_analysis_plugin()
1346 {
1347         boost::shared_ptr<Plugin> ret;
1348         if (_impulseAnalysisPlugin.expired()) {
1349                 ret = plugin_factory(_plugins[0]);
1350                 _impulseAnalysisPlugin = ret;
1351         } else {
1352                 ret = _impulseAnalysisPlugin.lock();
1353         }
1354
1355         return ret;
1356 }
1357
1358 void
1359 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1360 {
1361         // called from outside the audio thread, so this should be safe
1362         // only do audio as analysis is (currently) only for audio plugins
1363         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, input_streams().n_audio(),  nframes);
1364         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1365
1366         _signal_analysis_collected_nframes   = 0;
1367         _signal_analysis_collect_nframes_max = nframes;
1368 }
1369
1370 /** Add a plugin to our list */
1371 void
1372 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1373 {
1374         plugin->set_insert_id (this->id());
1375
1376         if (_plugins.empty()) {
1377                 /* first (and probably only) plugin instance - connect to relevant signals
1378                  */
1379
1380                 plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
1381                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1382                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1383         }
1384
1385         _plugins.push_back (plugin);
1386 }
1387
1388 void
1389 PluginInsert::realtime_handle_transport_stopped ()
1390 {
1391         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1392                 (*i)->realtime_handle_transport_stopped ();
1393         }
1394 }
1395
1396 void
1397 PluginInsert::realtime_locate ()
1398 {
1399         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1400                 (*i)->realtime_locate ();
1401         }
1402 }
1403
1404 void
1405 PluginInsert::monitoring_changed ()
1406 {
1407         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1408                 (*i)->monitoring_changed ();
1409         }
1410 }
1411
1412 void
1413 PluginInsert::start_touch (uint32_t param_id)
1414 {
1415         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1416         if (ac) {
1417                 ac->start_touch (session().audible_frame());
1418         }
1419 }
1420
1421 void
1422 PluginInsert::end_touch (uint32_t param_id)
1423 {
1424         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1425         if (ac) {
1426                 ac->stop_touch (true, session().audible_frame());
1427         }
1428 }