libs/ardour/plugin_insert.cc

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