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