libs/ardour/plugin_insert.cc

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