libs/ardour/plugin_insert.cc

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