libs/ardour/plugin_insert.cc

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