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         const PinMappings old_in (_in_map);
1248         const PinMappings old_out (_out_map);
1249
1250         _in_map.clear ();
1251         _out_map.clear ();
1252         _thru_map = ChanMapping ();
1253
1254         /* build input map */
1255         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1256                 uint32_t sc = 0; // side-chain round-robin (all instances)
1257                 uint32_t pc = 0;
1258                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1259                         const uint32_t nis = natural_input_streams ().get(*t);
1260                         const uint32_t stride = nis - sidechain_input_pins().get (*t);
1261
1262                         /* SC inputs are last in the plugin-insert.. */
1263                         const uint32_t sc_start = _configured_in.get (*t);
1264                         const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1265                         /* ...but may not be at the end of the plugin ports.
1266                          * in case the side-chain is not the last port, shift connections back.
1267                          * and connect to side-chain
1268                          */
1269                         uint32_t shift = 0;
1270                         uint32_t ic = 0; // split inputs
1271                         const uint32_t cend = _configured_in.get (*t);
1272
1273                         for (uint32_t in = 0; in < nis; ++in) {
1274                                 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1275                                 if (iod.is_sidechain) {
1276                                         /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1277                                         if (sc_len > 0) {// side-chain may be hidden
1278                                                 _in_map[pc].set (*t, in, sc_start + sc);
1279                                                 sc = (sc + 1) % sc_len;
1280                                         }
1281                                         ++shift;
1282                                 } else {
1283                                         if (_match.method == Split) {
1284                                                 if (cend == 0) { continue; }
1285                                                 /* connect *no* sidechain sinks in round-robin fashion */
1286                                                 _in_map[pc].set (*t, in, ic + stride * pc);
1287                                                 ic = (ic + 1) % cend;
1288                                         } else {
1289                                                 uint32_t s = in - shift;
1290                                                 if (stride * pc + s < cend) {
1291                                                         _in_map[pc].set (*t, in, stride * pc + s);
1292                                                 }
1293                                         }
1294                                 }
1295                         }
1296                 }
1297         }
1298
1299         /* build output map */
1300         uint32_t pc = 0;
1301         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1302                 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1303                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1304                         _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1305                 }
1306         }
1307
1308         sanitize_maps ();
1309         if (old_in == _in_map && old_out == _out_map) {
1310                 return false;
1311         }
1312         if (emit) {
1313                 PluginMapChanged (); /* EMIT SIGNAL */
1314                 _mapping_changed = true;
1315                 _session.set_dirty();
1316         }
1317         return true;
1318 }
1319
1320 bool
1321 PluginInsert::configure_io (ChanCount in, ChanCount out)
1322 {
1323         Match old_match = _match;
1324         ChanCount old_in;
1325         ChanCount old_internal;
1326         ChanCount old_out;
1327
1328         if (_configured) {
1329                 old_in = _configured_in;
1330                 old_internal = _configured_internal;
1331                 old_out = _configured_out;
1332         }
1333
1334         _configured_in = in;
1335         _configured_internal = in;
1336         _configured_out = out;
1337
1338         if (_sidechain) {
1339                 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1340                  * (currently _sidechain->configure_io always succeeds
1341                  *  since Processor::configure_io() succeeds)
1342                  */
1343                 if (!_sidechain->configure_io (in, out)) {
1344                         DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1345                         return false;
1346                 }
1347                 _configured_internal += _sidechain->input()->n_ports();
1348         }
1349
1350         /* get plugin configuration */
1351         _match = private_can_support_io_configuration (in, out);
1352 #ifndef NDEBUG
1353         if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1354                 DEBUG_STR_DECL(a);
1355                 DEBUG_STR_APPEND(a, string_compose ("Match '%1': ",  name()));
1356                 DEBUG_STR_APPEND(a, _match);
1357                 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1358         }
1359 #endif
1360
1361         /* set the matching method and number of plugins that we will use to meet this configuration */
1362         if (set_count (_match.plugins) == false) {
1363                 PluginIoReConfigure (); /* EMIT SIGNAL */
1364                 _configured = false;
1365                 return false;
1366         }
1367
1368         /* configure plugins */
1369         switch (_match.method) {
1370         case Split:
1371         case Hide:
1372                 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1373                         PluginIoReConfigure (); /* EMIT SIGNAL */
1374                         _configured = false;
1375                         return false;
1376                 }
1377                 break;
1378         case Delegate:
1379                 {
1380                         ChanCount dout;
1381                         ChanCount useins;
1382                         bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1383                         assert (r);
1384                         assert (_match.strict_io || dout.n_audio() == out.n_audio()); // sans midi bypass
1385                         if (useins.n_audio() == 0) {
1386                                 useins = in;
1387                         }
1388                         if (_plugins.front()->configure_io (useins, dout) == false) {
1389                                 PluginIoReConfigure (); /* EMIT SIGNAL */
1390                                 _configured = false;
1391                                 return false;
1392                         }
1393                 }
1394                 break;
1395         default:
1396                 if (_plugins.front()->configure_io (in, out) == false) {
1397                         PluginIoReConfigure (); /* EMIT SIGNAL */
1398                         _configured = false;
1399                         return false;
1400                 }
1401                 break;
1402         }
1403
1404         bool mapping_changed = false;
1405         if (old_in == in && old_out == out
1406                         && _configured
1407                         && old_match.method == _match.method
1408                         && _in_map.size() == _out_map.size()
1409                         && _in_map.size() == get_count ()
1410                  ) {
1411                 /* If the configuration has not changed, keep the mapping */
1412                 if (old_internal != _configured_internal) {
1413                         mapping_changed = sanitize_maps ();
1414                 }
1415         } else if (_match.custom_cfg && _configured) {
1416                 mapping_changed = sanitize_maps ();
1417         } else {
1418 #ifdef MIXBUS
1419                 if (is_channelstrip ()) { _maps_from_state = false; }
1420 #endif
1421                 if (_maps_from_state) {
1422                         _maps_from_state = false;
1423                         mapping_changed = true;
1424                         sanitize_maps ();
1425                 } else {
1426                         /* generate a new mapping */
1427                         mapping_changed = reset_map (false);
1428                 }
1429         }
1430
1431         if (mapping_changed) {
1432                 PluginMapChanged (); /* EMIT SIGNAL */
1433
1434 #ifndef NDEBUG
1435                 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1436                         uint32_t pc = 0;
1437                         DEBUG_STR_DECL(a);
1438                         DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1439                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1440                                 if (pc > 0) {
1441                         DEBUG_STR_APPEND(a, "----><----\n");
1442                                 }
1443                                 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1444                                 DEBUG_STR_APPEND(a, " * Inputs:\n");
1445                                 DEBUG_STR_APPEND(a, _in_map[pc]);
1446                                 DEBUG_STR_APPEND(a, " * Outputs:\n");
1447                                 DEBUG_STR_APPEND(a, _out_map[pc]);
1448                         }
1449                         DEBUG_STR_APPEND(a, " * Thru:\n");
1450                         DEBUG_STR_APPEND(a, _thru_map);
1451                         DEBUG_STR_APPEND(a, "-------->>--------\n");
1452                         DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1453                 }
1454 #endif
1455         }
1456
1457         _no_inplace = check_inplace ();
1458         _mapping_changed = false;
1459
1460         if (old_in != in || old_out != out || old_internal != _configured_internal
1461                         || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1462                  ) {
1463                 PluginIoReConfigure (); /* EMIT SIGNAL */
1464         }
1465
1466         _delaybuffers.configure (_configured_out, _plugins.front()->max_latency ());
1467         _latency_changed = true;
1468
1469         // we don't know the analysis window size, so we must work with the
1470         // current buffer size here. each request for data fills in these
1471         // buffers and the analyser makes sure it gets enough data for the
1472         // analysis window
1473         session().ensure_buffer_set (_signal_analysis_inputs, in);
1474         //_signal_analysis_inputs.set_count (in);
1475
1476         session().ensure_buffer_set (_signal_analysis_outputs, out);
1477         //_signal_analysis_outputs.set_count (out);
1478
1479         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1480
1481         _configured = true;
1482         return Processor::configure_io (in, out);
1483 }
1484
1485 /** Decide whether this PluginInsert can support a given IO configuration.
1486  *  To do this, we run through a set of possible solutions in rough order of
1487  *  preference.
1488  *
1489  *  @param in Required input channel count.
1490  *  @param out Filled in with the output channel count if we return true.
1491  *  @return true if the given IO configuration can be supported.
1492  */
1493 bool
1494 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1495 {
1496         if (_sidechain) {
1497                 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1498         }
1499         return private_can_support_io_configuration (in, out).method != Impossible;
1500 }
1501
1502 /** A private version of can_support_io_configuration which returns the method
1503  *  by which the configuration can be matched, rather than just whether or not
1504  *  it can be.
1505  */
1506 PluginInsert::Match
1507 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1508 {
1509         if (_plugins.empty()) {
1510                 return Match();
1511         }
1512
1513 #ifdef MIXBUS
1514         if (is_channelstrip ()) {
1515                 out = inx;
1516                 return Match (ExactMatch, 1);
1517         }
1518 #endif
1519
1520         /* if a user specified a custom cfg, so be it. */
1521         if (_custom_cfg) {
1522                 out = _custom_out;
1523                 return Match (ExactMatch, get_count(), _strict_io, true); // XXX
1524         }
1525
1526         /* try automatic configuration */
1527         Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1528
1529         PluginInfoPtr info = _plugins.front()->get_info();
1530         ChanCount inputs  = info->n_inputs;
1531         ChanCount outputs = info->n_outputs;
1532
1533         /* handle case strict-i/o */
1534         if (_strict_io && m.method != Impossible) {
1535                 m.strict_io = true;
1536
1537                 /* special case MIDI instruments */
1538                 if (is_midi_instrument()) {
1539                         // output = midi-bypass + at most master-out channels.
1540                         ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1541                         max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1542                         out = ChanCount::min (out, max_out);
1543                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o instrument: %1\n", name()));
1544                         return m;
1545                 }
1546
1547                 switch (m.method) {
1548                         case NoInputs:
1549                                 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1550                                         /* replicate processor to match output count (generators and such)
1551                                          * at least enough to feed every output port. */
1552                                         uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1553                                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1554                                                 uint32_t nout = outputs.get (*t);
1555                                                 if (nout == 0 || inx.get(*t) == 0) { continue; }
1556                                                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1557                                         }
1558                                         out = inx;
1559                                         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o generator: %1\n", name()));
1560                                         return Match (Replicate, f, _strict_io);
1561                                 }
1562                                 break;
1563                         default:
1564                                 break;
1565                 }
1566
1567                 out = inx;
1568                 return m;
1569         }
1570
1571         if (m.method != Impossible) {
1572                 return m;
1573         }
1574
1575         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1576
1577         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
1578
1579         if (info->reconfigurable_io()) {
1580                 ChanCount useins;
1581                 // TODO add sidechains here
1582                 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1583                 if (!r) {
1584                         // houston, we have a problem.
1585                         return Match (Impossible, 0);
1586                 }
1587                 return Match (Delegate, 1, _strict_io);
1588         }
1589
1590         ChanCount midi_bypass;
1591         if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1592                 midi_bypass.set (DataType::MIDI, 1);
1593         }
1594
1595         // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1596         uint32_t f = 0;
1597         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1598                 uint32_t nin = ns_inputs.get (*t);
1599                 uint32_t nout = outputs.get (*t);
1600                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1601                 // prefer floor() so the count won't overly increase IFF (nin < nout)
1602                 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1603         }
1604         if (f > 0 && outputs * f >= _configured_out) {
1605                 out = outputs * f + midi_bypass;
1606                 return Match (Replicate, f, _strict_io);
1607         }
1608
1609         // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1610         f = 0;
1611         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1612                 uint32_t nin = ns_inputs.get (*t);
1613                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1614                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1615         }
1616         if (f > 0) {
1617                 out = outputs * f + midi_bypass;
1618                 return Match (Replicate, f, _strict_io);
1619         }
1620
1621         // add at least as many plugins needed to connect all inputs
1622         f = 1;
1623         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1624                 uint32_t nin = inputs.get (*t);
1625                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1626                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1627         }
1628         out = outputs * f + midi_bypass;
1629         return Match (Replicate, f, _strict_io);
1630 }
1631
1632 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1633 PluginInsert::Match
1634 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1635 {
1636         if (_plugins.empty()) {
1637                 return Match();
1638         }
1639
1640         PluginInfoPtr info = _plugins.front()->get_info();
1641         ChanCount in; in += inx;
1642         ChanCount midi_bypass;
1643
1644         if (info->reconfigurable_io()) {
1645                 /* Plugin has flexible I/O, so delegate to it */
1646                 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1647                 if (!r) {
1648                         return Match (Impossible, 0);
1649                 }
1650                 return Match (Delegate, 1);
1651         }
1652
1653         ChanCount inputs  = info->n_inputs;
1654         ChanCount outputs = info->n_outputs;
1655         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1656
1657         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1658                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1659                 midi_bypass.set (DataType::MIDI, 1);
1660         }
1661         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1662                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1663                 in.set(DataType::MIDI, 0);
1664         }
1665
1666         // add internally provided sidechain ports
1667         ChanCount insc = in + sidechain_input_ports ();
1668
1669         bool no_inputs = true;
1670         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1671                 if (inputs.get (*t) != 0) {
1672                         no_inputs = false;
1673                         break;
1674                 }
1675         }
1676
1677         if (no_inputs) {
1678                 /* no inputs so we can take any input configuration since we throw it away */
1679                 out = outputs + midi_bypass;
1680                 return Match (NoInputs, 1);
1681         }
1682
1683         /* Plugin inputs match requested inputs + side-chain-ports exactly */
1684         if (inputs == insc) {
1685                 out = outputs + midi_bypass;
1686                 return Match (ExactMatch, 1);
1687         }
1688
1689         /* Plugin inputs matches without side-chain-pins */
1690         if (ns_inputs == in) {
1691                 out = outputs + midi_bypass;
1692                 return Match (ExactMatch, 1);
1693         }
1694
1695         /* We may be able to run more than one copy of the plugin within this insert
1696            to cope with the insert having more inputs than the plugin.
1697            We allow replication only for plugins with either zero or 1 inputs and outputs
1698            for every valid data type.
1699         */
1700
1701         uint32_t f             = 0;
1702         bool     can_replicate = true;
1703         for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
1704
1705                 // ignore side-chains
1706                 uint32_t nin = ns_inputs.get (*t);
1707
1708                 // No inputs of this type
1709                 if (nin == 0 && in.get(*t) == 0) {
1710                         continue;
1711                 }
1712
1713                 if (nin != 1 || outputs.get (*t) != 1) {
1714                         can_replicate = false;
1715                         break;
1716                 }
1717
1718                 // Potential factor not set yet
1719                 if (f == 0) {
1720                         f = in.get(*t) / nin;
1721                 }
1722
1723                 // Factor for this type does not match another type, can not replicate
1724                 if (f != (in.get(*t) / nin)) {
1725                         can_replicate = false;
1726                         break;
1727                 }
1728         }
1729
1730         if (can_replicate && f > 0) {
1731                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1732                         out.set (*t, outputs.get(*t) * f);
1733                 }
1734                 out += midi_bypass;
1735                 return Match (Replicate, f);
1736         }
1737
1738         /* If the processor has exactly one input of a given type, and
1739            the plugin has more, we can feed the single processor input
1740            to some or all of the plugin inputs.  This is rather
1741            special-case-y, but the 1-to-many case is by far the
1742            simplest.  How do I split thy 2 processor inputs to 3
1743            plugin inputs?  Let me count the ways ...
1744         */
1745
1746         bool can_split = true;
1747         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1748
1749                 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
1750                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1751
1752                 if (!can_split_type && !nothing_to_do_for_type) {
1753                         can_split = false;
1754                 }
1755         }
1756
1757         if (can_split) {
1758                 out = outputs + midi_bypass;
1759                 return Match (Split, 1);
1760         }
1761
1762         /* If the plugin has more inputs than we want, we can `hide' some of them
1763            by feeding them silence.
1764         */
1765
1766         bool could_hide = false;
1767         bool cannot_hide = false;
1768         ChanCount hide_channels;
1769
1770         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1771                 if (inputs.get(*t) > in.get(*t)) {
1772                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1773                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1774                         could_hide = true;
1775                 } else if (inputs.get(*t) < in.get(*t)) {
1776                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1777                         cannot_hide = true;
1778                 }
1779         }
1780
1781         if (could_hide && !cannot_hide) {
1782                 out = outputs + midi_bypass;
1783                 return Match (Hide, 1, false, false, hide_channels);
1784         }
1785
1786         return Match (Impossible, 0);
1787 }
1788
1789
1790 XMLNode&
1791 PluginInsert::get_state ()
1792 {
1793         return state (true);
1794 }
1795
1796 XMLNode&
1797 PluginInsert::state (bool full)
1798 {
1799         XMLNode& node = Processor::state (full);
1800
1801         node.add_property("type", _plugins[0]->state_node_name());
1802         node.add_property("unique-id", _plugins[0]->unique_id());
1803         node.add_property("count", string_compose("%1", _plugins.size()));
1804
1805         /* remember actual i/o configuration (for later placeholder
1806          * in case the plugin goes missing) */
1807         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1808         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1809
1810         /* save custom i/o config */
1811         node.add_property("custom", _custom_cfg ? "yes" : "no");
1812         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1813                 char tmp[128];
1814                 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1815                 node.add_child_nocopy (* _in_map[pc].state (tmp));
1816                 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1817                 node.add_child_nocopy (* _out_map[pc].state (tmp));
1818         }
1819         node.add_child_nocopy (* _thru_map.state ("ThruMap"));
1820
1821         if (_sidechain) {
1822                 node.add_child_nocopy (_sidechain->state (full));
1823         }
1824
1825         _plugins[0]->set_insert_id(this->id());
1826         node.add_child_nocopy (_plugins[0]->get_state());
1827
1828         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1829                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1830                 if (ac) {
1831                         node.add_child_nocopy (ac->get_state());
1832                 }
1833         }
1834
1835         return node;
1836 }
1837
1838 void
1839 PluginInsert::set_control_ids (const XMLNode& node, int version)
1840 {
1841         const XMLNodeList& nlist = node.children();
1842         XMLNodeConstIterator iter;
1843         set<Evoral::Parameter>::const_iterator p;
1844
1845         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1846                 if ((*iter)->name() == Controllable::xml_node_name) {
1847                         const XMLProperty* prop;
1848
1849                         uint32_t p = (uint32_t)-1;
1850 #ifdef LV2_SUPPORT
1851                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1852                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1853                                 if (lv2plugin) {
1854                                         p = lv2plugin->port_index(prop->value().c_str());
1855                                 }
1856                         }
1857 #endif
1858                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1859                                 p = atoi (prop->value());
1860                         }
1861
1862                         if (p != (uint32_t)-1) {
1863
1864                                 /* this may create the new controllable */
1865
1866                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1867
1868 #ifndef NO_PLUGIN_STATE
1869                                 if (!c) {
1870                                         continue;
1871                                 }
1872                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1873                                 if (ac) {
1874                                         ac->set_state (**iter, version);
1875                                 }
1876 #endif
1877                         }
1878                 }
1879         }
1880 }
1881
1882 int
1883 PluginInsert::set_state(const XMLNode& node, int version)
1884 {
1885         XMLNodeList nlist = node.children();
1886         XMLNodeIterator niter;
1887         XMLPropertyList plist;
1888         const XMLProperty *prop;
1889         ARDOUR::PluginType type;
1890
1891         if ((prop = node.property ("type")) == 0) {
1892                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1893                 return -1;
1894         }
1895
1896         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1897                 type = ARDOUR::LADSPA;
1898         } else if (prop->value() == X_("lv2")) {
1899                 type = ARDOUR::LV2;
1900         } else if (prop->value() == X_("windows-vst")) {
1901                 type = ARDOUR::Windows_VST;
1902         } else if (prop->value() == X_("lxvst")) {
1903                 type = ARDOUR::LXVST;
1904         } else if (prop->value() == X_("audiounit")) {
1905                 type = ARDOUR::AudioUnit;
1906         } else if (prop->value() == X_("luaproc")) {
1907                 type = ARDOUR::Lua;
1908         } else {
1909                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1910                                   prop->value())
1911                       << endmsg;
1912                 return -1;
1913         }
1914
1915         prop = node.property ("unique-id");
1916
1917         if (prop == 0) {
1918 #ifdef WINDOWS_VST_SUPPORT
1919                 /* older sessions contain VST plugins with only an "id" field.
1920                  */
1921
1922                 if (type == ARDOUR::Windows_VST) {
1923                         prop = node.property ("id");
1924                 }
1925 #endif
1926
1927 #ifdef LXVST_SUPPORT
1928                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1929
1930                 if (type == ARDOUR::LXVST) {
1931                         prop = node.property ("id");
1932                 }
1933 #endif
1934                 /* recheck  */
1935
1936                 if (prop == 0) {
1937                         error << _("Plugin has no unique ID field") << endmsg;
1938                         return -1;
1939                 }
1940         }
1941
1942         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1943
1944         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1945          * allow to move sessions windows <> linux */
1946 #ifdef LXVST_SUPPORT
1947         if (plugin == 0 && type == ARDOUR::Windows_VST) {
1948                 type = ARDOUR::LXVST;
1949                 plugin = find_plugin (_session, prop->value(), type);
1950         }
1951 #endif
1952
1953 #ifdef WINDOWS_VST_SUPPORT
1954         if (plugin == 0 && type == ARDOUR::LXVST) {
1955                 type = ARDOUR::Windows_VST;
1956                 plugin = find_plugin (_session, prop->value(), type);
1957         }
1958 #endif
1959
1960         if (plugin == 0) {
1961                 error << string_compose(
1962                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1963                           "Perhaps it was removed or moved since it was last used."),
1964                         prop->value())
1965                       << endmsg;
1966                 return -1;
1967         }
1968
1969         if (type == ARDOUR::Lua) {
1970                 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1971                 // we need to load the script to set the name and parameters.
1972                 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1973                 if (ls && lp) {
1974                         lp->set_script_from_state (*ls);
1975                 }
1976         }
1977
1978         // The name of the PluginInsert comes from the plugin, nothing else
1979         _name = plugin->get_info()->name;
1980
1981         uint32_t count = 1;
1982
1983         // Processor::set_state() will set this, but too late
1984         // for it to be available when setting up plugin
1985         // state. We can't call Processor::set_state() until
1986         // the plugins themselves are created and added.
1987
1988         set_id (node);
1989
1990         if (_plugins.empty()) {
1991                 /* if we are adding the first plugin, we will need to set
1992                    up automatable controls.
1993                 */
1994                 add_plugin (plugin);
1995                 create_automatable_parameters ();
1996                 set_control_ids (node, version);
1997         }
1998
1999         if ((prop = node.property ("count")) != 0) {
2000                 sscanf (prop->value().c_str(), "%u", &count);
2001         }
2002
2003         if (_plugins.size() != count) {
2004                 for (uint32_t n = 1; n < count; ++n) {
2005                         add_plugin (plugin_factory (plugin));
2006                 }
2007         }
2008
2009         Processor::set_state (node, version);
2010
2011         PBD::ID new_id = this->id();
2012         PBD::ID old_id = this->id();
2013
2014         if ((prop = node.property ("id")) != 0) {
2015                 old_id = prop->value ();
2016         }
2017
2018         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2019
2020                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2021                    and set all plugins to the same state.
2022                 */
2023
2024                 if ((*niter)->name() == plugin->state_node_name()) {
2025
2026                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2027                                 /* Plugin state can include external files which are named after the ID.
2028                                  *
2029                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
2030                                  * been changed, so we need to use the old ID from the XML to load the
2031                                  * state and then update the ID.
2032                                  *
2033                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
2034                                  * but we need to call set_insert_id() to clear the cached plugin-state
2035                                  * and force a change.
2036                                  */
2037                                 if (!regenerate_xml_or_string_ids ()) {
2038                                         (*i)->set_insert_id (new_id);
2039                                 } else {
2040                                         (*i)->set_insert_id (old_id);
2041                                 }
2042
2043                                 (*i)->set_state (**niter, version);
2044
2045                                 if (regenerate_xml_or_string_ids ()) {
2046                                         (*i)->set_insert_id (new_id);
2047                                 }
2048                         }
2049
2050                         break;
2051                 }
2052         }
2053
2054         if (version < 3000) {
2055
2056                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2057                    this is all handled by Automatable
2058                 */
2059
2060                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2061                         if ((*niter)->name() == "Redirect") {
2062                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2063                                 Processor::set_state (**niter, version);
2064                                 break;
2065                         }
2066                 }
2067
2068                 set_parameter_state_2X (node, version);
2069         }
2070
2071         if ((prop = node.property (X_("custom"))) != 0) {
2072                 _custom_cfg = string_is_affirmative (prop->value());
2073         }
2074
2075         uint32_t in_maps = 0;
2076         uint32_t out_maps = 0;
2077         XMLNodeList kids = node.children ();
2078         for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2079                 if ((*i)->name() == X_("ConfiguredOutput")) {
2080                         _custom_out = ChanCount(**i);
2081                 }
2082                 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2083                         long pc = atol (&((*i)->name().c_str()[9]));
2084                         if (pc >=0 && pc <= get_count()) {
2085                                 _in_map[pc] = ChanMapping (**i);
2086                                 ++in_maps;
2087                         }
2088                 }
2089                 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2090                         long pc = atol (&((*i)->name().c_str()[10]));
2091                         if (pc >=0 && pc <= get_count()) {
2092                                 _out_map[pc] = ChanMapping (**i);
2093                                 ++out_maps;
2094                         }
2095                 }
2096                 if ((*i)->name () ==  "ThruMap") {
2097                                 _thru_map = ChanMapping (**i);
2098                 }
2099
2100                 // sidechain is a Processor (IO)
2101                 if ((*i)->name () ==  Processor::state_node_name) {
2102                         if (!_sidechain) {
2103                                 add_sidechain (0);
2104                         }
2105                         _sidechain->set_state (**i, version);
2106                 }
2107         }
2108
2109         if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2110                 _maps_from_state = true;
2111         }
2112
2113         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2114                 if (active()) {
2115                         (*i)->activate ();
2116                 } else {
2117                         (*i)->deactivate ();
2118                 }
2119         }
2120
2121         PluginConfigChanged (); /* EMIT SIGNAL */
2122         return 0;
2123 }
2124
2125 void
2126 PluginInsert::update_id (PBD::ID id)
2127 {
2128         set_id (id.to_s());
2129         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2130                 (*i)->set_insert_id (id);
2131         }
2132 }
2133
2134 void
2135 PluginInsert::set_state_dir (const std::string& d)
2136 {
2137         // state() only saves the state of the first plugin
2138         _plugins[0]->set_state_dir (d);
2139 }
2140
2141 void
2142 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2143 {
2144         XMLNodeList nlist = node.children();
2145         XMLNodeIterator niter;
2146
2147         /* look for port automation node */
2148
2149         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2150
2151                 if ((*niter)->name() != port_automation_node_name) {
2152                         continue;
2153                 }
2154
2155                 XMLNodeList cnodes;
2156                 XMLProperty *cprop;
2157                 XMLNodeConstIterator iter;
2158                 XMLNode *child;
2159                 const char *port;
2160                 uint32_t port_id;
2161
2162                 cnodes = (*niter)->children ("port");
2163
2164                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2165
2166                         child = *iter;
2167
2168                         if ((cprop = child->property("number")) != 0) {
2169                                 port = cprop->value().c_str();
2170                         } else {
2171                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2172                                 continue;
2173                         }
2174
2175                         sscanf (port, "%" PRIu32, &port_id);
2176
2177                         if (port_id >= _plugins[0]->parameter_count()) {
2178                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2179                                 continue;
2180                         }
2181
2182                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2183                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2184
2185                         if (c && c->alist()) {
2186                                 if (!child->children().empty()) {
2187                                         c->alist()->set_state (*child->children().front(), version);
2188
2189                                         /* In some cases 2.X saves lists with min_yval and max_yval
2190                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
2191                                            in A3 because these min/max values are used to compute
2192                                            where GUI control points should be drawn.  If we see such
2193                                            values, `correct' them to the min/max of the appropriate
2194                                            parameter.
2195                                         */
2196
2197                                         float min_y = c->alist()->get_min_y ();
2198                                         float max_y = c->alist()->get_max_y ();
2199
2200                                         ParameterDescriptor desc;
2201                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
2202
2203                                         if (min_y == FLT_MIN) {
2204                                                 min_y = desc.lower;
2205                                         }
2206
2207                                         if (max_y == FLT_MAX) {
2208                                                 max_y = desc.upper;
2209                                         }
2210
2211                                         c->alist()->set_yrange (min_y, max_y);
2212                                 }
2213                         } else {
2214                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2215                         }
2216                 }
2217
2218                 /* done */
2219
2220                 break;
2221         }
2222 }
2223
2224
2225 string
2226 PluginInsert::describe_parameter (Evoral::Parameter param)
2227 {
2228         if (param.type() == PluginAutomation) {
2229                 return _plugins[0]->describe_parameter (param);
2230         } else if (param.type() == PluginPropertyAutomation) {
2231                 boost::shared_ptr<AutomationControl> c(automation_control(param));
2232                 if (c && !c->desc().label.empty()) {
2233                         return c->desc().label;
2234                 }
2235         }
2236         return Automatable::describe_parameter(param);
2237 }
2238
2239 ARDOUR::framecnt_t
2240 PluginInsert::signal_latency() const
2241 {
2242         if (_user_latency) {
2243                 return _user_latency;
2244         }
2245
2246         return _plugins[0]->signal_latency ();
2247 }
2248
2249 ARDOUR::PluginType
2250 PluginInsert::type ()
2251 {
2252        return plugin()->get_info()->type;
2253 }
2254
2255 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
2256                                             const Evoral::Parameter&          param,
2257                                             const ParameterDescriptor&        desc,
2258                                             boost::shared_ptr<AutomationList> list)
2259         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2260         , _plugin (p)
2261 {
2262         if (alist()) {
2263                 alist()->reset_default (desc.normal);
2264                 if (desc.toggled) {
2265                         list->set_interpolation(Evoral::ControlList::Discrete);
2266                 }
2267         }
2268
2269         if (desc.toggled) {
2270                 set_flags(Controllable::Toggle);
2271         }
2272 }
2273
2274 /** @param val `user' value */
2275 void
2276 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2277 {
2278         if (writable()) {
2279                 _set_value (user_val, group_override);
2280         }
2281 }
2282 void
2283 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2284 {
2285         /* used only by automation playback */
2286         _set_value (user_val, Controllable::NoGroup);
2287 }
2288
2289 void
2290 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2291 {
2292         /* FIXME: probably should be taking out some lock here.. */
2293
2294         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2295                 (*i)->set_parameter (_list->parameter().id(), user_val);
2296         }
2297
2298         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2299         if (iasp) {
2300                 iasp->set_parameter (_list->parameter().id(), user_val);
2301         }
2302
2303         AutomationControl::set_value (user_val, group_override);
2304 }
2305
2306 void
2307 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2308 {
2309         AutomationControl::set_value (user_val, Controllable::NoGroup);
2310 }
2311
2312 XMLNode&
2313 PluginInsert::PluginControl::get_state ()
2314 {
2315         stringstream ss;
2316
2317         XMLNode& node (AutomationControl::get_state());
2318         ss << parameter().id();
2319         node.add_property (X_("parameter"), ss.str());
2320 #ifdef LV2_SUPPORT
2321         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2322         if (lv2plugin) {
2323                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2324         }
2325 #endif
2326
2327         return node;
2328 }
2329
2330 /** @return `user' val */
2331 double
2332 PluginInsert::PluginControl::get_value () const
2333 {
2334         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2335
2336         if (!plugin) {
2337                 return 0.0;
2338         }
2339
2340         return plugin->get_parameter (_list->parameter().id());
2341 }
2342
2343 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
2344                                                             const Evoral::Parameter&          param,
2345                                                             const ParameterDescriptor&        desc,
2346                                                             boost::shared_ptr<AutomationList> list)
2347         : AutomationControl (p->session(), param, desc, list)
2348         , _plugin (p)
2349 {
2350         if (alist()) {
2351                 alist()->set_yrange (desc.lower, desc.upper);
2352                 alist()->reset_default (desc.normal);
2353         }
2354
2355         if (desc.toggled) {
2356                 set_flags(Controllable::Toggle);
2357         }
2358 }
2359
2360 void
2361 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2362 {
2363         if (writable()) {
2364                 set_value_unchecked (user_val);
2365         }
2366 }
2367
2368 void
2369 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2370 {
2371         /* Old numeric set_value(), coerce to appropriate datatype if possible.
2372            This is lossy, but better than nothing until Ardour's automation system
2373            can handle various datatypes all the way down. */
2374         const Variant value(_desc.datatype, user_val);
2375         if (value.type() == Variant::NOTHING) {
2376                 error << "set_value(double) called for non-numeric property" << endmsg;
2377                 return;
2378         }
2379
2380         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2381                 (*i)->set_property(_list->parameter().id(), value);
2382         }
2383
2384         _value = value;
2385         AutomationControl::set_value (user_val, Controllable::NoGroup);
2386 }
2387
2388 XMLNode&
2389 PluginInsert::PluginPropertyControl::get_state ()
2390 {
2391         stringstream ss;
2392
2393         XMLNode& node (AutomationControl::get_state());
2394         ss << parameter().id();
2395         node.add_property (X_("property"), ss.str());
2396         node.remove_property (X_("value"));
2397
2398         return node;
2399 }
2400
2401 double
2402 PluginInsert::PluginPropertyControl::get_value () const
2403 {
2404         return _value.to_double();
2405 }
2406
2407 boost::shared_ptr<Plugin>
2408 PluginInsert::get_impulse_analysis_plugin()
2409 {
2410         boost::shared_ptr<Plugin> ret;
2411         if (_impulseAnalysisPlugin.expired()) {
2412                 ret = plugin_factory(_plugins[0]);
2413                 ret->configure_io (internal_input_streams (), internal_output_streams ());
2414                 _impulseAnalysisPlugin = ret;
2415         } else {
2416                 ret = _impulseAnalysisPlugin.lock();
2417         }
2418
2419         return ret;
2420 }
2421
2422 void
2423 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2424 {
2425         // called from outside the audio thread, so this should be safe
2426         // only do audio as analysis is (currently) only for audio plugins
2427         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, internal_input_streams().n_audio(),  nframes);
2428         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2429
2430         _signal_analysis_collected_nframes   = 0;
2431         _signal_analysis_collect_nframes_max = nframes;
2432 }
2433
2434 /** Add a plugin to our list */
2435 void
2436 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2437 {
2438         plugin->set_insert_id (this->id());
2439
2440         if (_plugins.empty()) {
2441                 /* first (and probably only) plugin instance - connect to relevant signals */
2442
2443                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2444                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2445                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2446                 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2447                 // cache sidechain port count
2448                 _cached_sidechain_pins.reset ();
2449                 const ChanCount& nis (plugin->get_info()->n_inputs);
2450                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2451                         for (uint32_t in = 0; in < nis.get (*t); ++in) {
2452                                 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2453                                 if (iod.is_sidechain) {
2454                                         _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2455                                 }
2456                         }
2457                 }
2458         }
2459 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2460         boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2461         if (vst) {
2462                 vst->set_insert (this, _plugins.size ());
2463         }
2464 #endif
2465         _plugins.push_back (plugin);
2466 }
2467
2468 void
2469 PluginInsert::realtime_handle_transport_stopped ()
2470 {
2471         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2472                 (*i)->realtime_handle_transport_stopped ();
2473         }
2474 }
2475
2476 void
2477 PluginInsert::realtime_locate ()
2478 {
2479         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2480                 (*i)->realtime_locate ();
2481         }
2482 }
2483
2484 void
2485 PluginInsert::monitoring_changed ()
2486 {
2487         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2488                 (*i)->monitoring_changed ();
2489         }
2490 }
2491
2492 void
2493 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2494 {
2495         // this is called in RT context, LatencyChanged is emitted after run()
2496         _latency_changed = true;
2497 }
2498
2499 void
2500 PluginInsert::start_touch (uint32_t param_id)
2501 {
2502         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2503         if (ac) {
2504                 ac->start_touch (session().audible_frame());
2505         }
2506 }
2507
2508 void
2509 PluginInsert::end_touch (uint32_t param_id)
2510 {
2511         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2512         if (ac) {
2513                 ac->stop_touch (true, session().audible_frame());
2514         }
2515 }
2516
2517 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2518 {
2519         switch (m.method) {
2520                 case PluginInsert::Impossible: o << "Impossible"; break;
2521                 case PluginInsert::Delegate:   o << "Delegate"; break;
2522                 case PluginInsert::NoInputs:   o << "NoInputs"; break;
2523                 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2524                 case PluginInsert::Replicate:  o << "Replicate"; break;
2525                 case PluginInsert::Split:      o << "Split"; break;
2526                 case PluginInsert::Hide:       o << "Hide"; break;
2527         }
2528         o << " cnt: " << m.plugins
2529                 << (m.strict_io ? " strict-io" : "")
2530                 << (m.custom_cfg ? " custom-cfg" : "");
2531         if (m.method == PluginInsert::Hide) {
2532                 o << " hide: " << m.hide;
2533         }
2534         o << "\n";
2535         return o;
2536 }