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