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