libs/ardour/plugin_insert.cc

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