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