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