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