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                         default:
1372                                 break;
1373                 }
1374
1375                 out = inx;
1376                 return m;
1377         }
1378
1379         if (m.method != Impossible) {
1380                 return m;
1381         }
1382
1383 #ifdef MIXBUS
1384         if (is_channelstrip ()) {
1385                 return Match (Replicate, 1, _strict_io);
1386         }
1387 #endif
1388
1389         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1390
1391         DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
1392
1393         if (info->reconfigurable_io()) {
1394                 ChanCount useins;
1395                 // TODO add sidechains here
1396                 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1397                 if (!r) {
1398                         // houston, we have a problem.
1399                         return Match (Impossible, 0);
1400                 }
1401                 return Match (Delegate, 1, _strict_io);
1402         }
1403
1404         ChanCount midi_bypass;
1405         if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1406                 midi_bypass.set (DataType::MIDI, 1);
1407         }
1408
1409         // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1410         uint32_t f = 0;
1411         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1412                 uint32_t nin = ns_inputs.get (*t);
1413                 uint32_t nout = outputs.get (*t);
1414                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1415                 // prefer floor() so the count won't overly increase IFF (nin < nout)
1416                 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1417         }
1418         if (f > 0 && outputs * f >= _configured_out) {
1419                 out = outputs * f + midi_bypass;
1420                 return Match (Replicate, f, _strict_io);
1421         }
1422
1423         // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1424         f = 0;
1425         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1426                 uint32_t nin = ns_inputs.get (*t);
1427                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1428                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1429         }
1430         if (f > 0) {
1431                 out = outputs * f + midi_bypass;
1432                 return Match (Replicate, f, _strict_io);
1433         }
1434
1435         // add at least as many plugins needed to connect all inputs
1436         f = 1;
1437         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1438                 uint32_t nin = inputs.get (*t);
1439                 if (nin == 0 || inx.get(*t) == 0) { continue; }
1440                 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1441         }
1442         out = outputs * f + midi_bypass;
1443         return Match (Replicate, f, _strict_io);
1444 }
1445
1446 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1447 PluginInsert::Match
1448 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1449 {
1450         if (_plugins.empty()) {
1451                 return Match();
1452         }
1453
1454         PluginInfoPtr info = _plugins.front()->get_info();
1455         ChanCount in; in += inx;
1456         ChanCount midi_bypass;
1457
1458         if (info->reconfigurable_io()) {
1459                 /* Plugin has flexible I/O, so delegate to it */
1460                 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1461                 if (!r) {
1462                         return Match (Impossible, 0);
1463                 }
1464                 return Match (Delegate, 1);
1465         }
1466
1467         ChanCount inputs  = info->n_inputs;
1468         ChanCount outputs = info->n_outputs;
1469         ChanCount ns_inputs  = inputs - sidechain_input_pins ();
1470
1471         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1472                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1473                 midi_bypass.set (DataType::MIDI, 1);
1474         }
1475         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1476                 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1477                 in.set(DataType::MIDI, 0);
1478         }
1479
1480         // add internally provided sidechain ports
1481         ChanCount insc = in + sidechain_input_ports ();
1482
1483         bool no_inputs = true;
1484         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1485                 if (inputs.get (*t) != 0) {
1486                         no_inputs = false;
1487                         break;
1488                 }
1489         }
1490
1491         if (no_inputs) {
1492                 /* no inputs so we can take any input configuration since we throw it away */
1493                 out = outputs + midi_bypass;
1494                 return Match (NoInputs, 1);
1495         }
1496
1497         /* Plugin inputs match requested inputs + side-chain-ports exactly */
1498         if (inputs == insc) {
1499                 out = outputs + midi_bypass;
1500                 return Match (ExactMatch, 1);
1501         }
1502
1503         /* Plugin inputs matches without side-chain-pins */
1504         if (ns_inputs == in) {
1505                 out = outputs + midi_bypass;
1506                 return Match (ExactMatch, 1);
1507         }
1508
1509         /* We may be able to run more than one copy of the plugin within this insert
1510            to cope with the insert having more inputs than the plugin.
1511            We allow replication only for plugins with either zero or 1 inputs and outputs
1512            for every valid data type.
1513         */
1514
1515         uint32_t f             = 0;
1516         bool     can_replicate = true;
1517 #ifdef MIXBUS
1518         if (is_channelstrip ()) {
1519                 can_replicate = false;
1520         }
1521 #endif
1522         for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
1523
1524                 // ignore side-chains
1525                 uint32_t nin = ns_inputs.get (*t);
1526
1527                 // No inputs of this type
1528                 if (nin == 0 && in.get(*t) == 0) {
1529                         continue;
1530                 }
1531
1532                 if (nin != 1 || outputs.get (*t) != 1) {
1533                         can_replicate = false;
1534                         break;
1535                 }
1536
1537                 // Potential factor not set yet
1538                 if (f == 0) {
1539                         f = in.get(*t) / nin;
1540                 }
1541
1542                 // Factor for this type does not match another type, can not replicate
1543                 if (f != (in.get(*t) / nin)) {
1544                         can_replicate = false;
1545                         break;
1546                 }
1547         }
1548
1549         if (can_replicate && f > 0) {
1550                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1551                         out.set (*t, outputs.get(*t) * f);
1552                 }
1553                 out += midi_bypass;
1554                 return Match (Replicate, f);
1555         }
1556
1557         /* If the processor has exactly one input of a given type, and
1558            the plugin has more, we can feed the single processor input
1559            to some or all of the plugin inputs.  This is rather
1560            special-case-y, but the 1-to-many case is by far the
1561            simplest.  How do I split thy 2 processor inputs to 3
1562            plugin inputs?  Let me count the ways ...
1563         */
1564
1565         bool can_split = true;
1566         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1567
1568                 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
1569                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1570
1571                 if (!can_split_type && !nothing_to_do_for_type) {
1572                         can_split = false;
1573                 }
1574         }
1575
1576         if (can_split) {
1577                 out = outputs + midi_bypass;
1578                 return Match (Split, 1);
1579         }
1580
1581         /* If the plugin has more inputs than we want, we can `hide' some of them
1582            by feeding them silence.
1583         */
1584
1585         bool could_hide = false;
1586         bool cannot_hide = false;
1587         ChanCount hide_channels;
1588
1589         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1590                 if (inputs.get(*t) > in.get(*t)) {
1591                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1592                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1593                         could_hide = true;
1594                 } else if (inputs.get(*t) < in.get(*t)) {
1595                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1596                         cannot_hide = true;
1597                 }
1598         }
1599
1600         if (could_hide && !cannot_hide) {
1601                 out = outputs + midi_bypass;
1602                 return Match (Hide, 1, false, false, hide_channels);
1603         }
1604
1605         return Match (Impossible, 0);
1606 }
1607
1608
1609 XMLNode&
1610 PluginInsert::get_state ()
1611 {
1612         return state (true);
1613 }
1614
1615 XMLNode&
1616 PluginInsert::state (bool full)
1617 {
1618         XMLNode& node = Processor::state (full);
1619
1620         node.add_property("type", _plugins[0]->state_node_name());
1621         node.add_property("unique-id", _plugins[0]->unique_id());
1622         node.add_property("count", string_compose("%1", _plugins.size()));
1623
1624         /* remember actual i/o configuration (for later placeholder
1625          * in case the plugin goes missing) */
1626         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1627         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1628
1629         /* save custom i/o config */
1630         node.add_property("custom", _custom_cfg ? "yes" : "no");
1631         for (uint32_t pc = 0; pc < get_count(); ++pc) {
1632                 char tmp[128];
1633                 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1634                 node.add_child_nocopy (* _in_map[pc].state (tmp));
1635                 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1636                 node.add_child_nocopy (* _out_map[pc].state (tmp));
1637         }
1638
1639         if (_sidechain) {
1640                 node.add_child_nocopy (_sidechain->state (full));
1641         }
1642
1643         _plugins[0]->set_insert_id(this->id());
1644         node.add_child_nocopy (_plugins[0]->get_state());
1645
1646         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1647                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1648                 if (ac) {
1649                         node.add_child_nocopy (ac->get_state());
1650                 }
1651         }
1652
1653         return node;
1654 }
1655
1656 void
1657 PluginInsert::set_control_ids (const XMLNode& node, int version)
1658 {
1659         const XMLNodeList& nlist = node.children();
1660         XMLNodeConstIterator iter;
1661         set<Evoral::Parameter>::const_iterator p;
1662
1663         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1664                 if ((*iter)->name() == Controllable::xml_node_name) {
1665                         const XMLProperty* prop;
1666
1667                         uint32_t p = (uint32_t)-1;
1668 #ifdef LV2_SUPPORT
1669                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1670                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1671                                 if (lv2plugin) {
1672                                         p = lv2plugin->port_index(prop->value().c_str());
1673                                 }
1674                         }
1675 #endif
1676                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1677                                 p = atoi (prop->value());
1678                         }
1679
1680                         if (p != (uint32_t)-1) {
1681
1682                                 /* this may create the new controllable */
1683
1684                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1685
1686 #ifndef NO_PLUGIN_STATE
1687                                 if (!c) {
1688                                         continue;
1689                                 }
1690                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1691                                 if (ac) {
1692                                         ac->set_state (**iter, version);
1693                                 }
1694 #endif
1695                         }
1696                 }
1697         }
1698 }
1699
1700 int
1701 PluginInsert::set_state(const XMLNode& node, int version)
1702 {
1703         XMLNodeList nlist = node.children();
1704         XMLNodeIterator niter;
1705         XMLPropertyList plist;
1706         const XMLProperty *prop;
1707         ARDOUR::PluginType type;
1708
1709         if ((prop = node.property ("type")) == 0) {
1710                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1711                 return -1;
1712         }
1713
1714         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1715                 type = ARDOUR::LADSPA;
1716         } else if (prop->value() == X_("lv2")) {
1717                 type = ARDOUR::LV2;
1718         } else if (prop->value() == X_("windows-vst")) {
1719                 type = ARDOUR::Windows_VST;
1720         } else if (prop->value() == X_("lxvst")) {
1721                 type = ARDOUR::LXVST;
1722         } else if (prop->value() == X_("audiounit")) {
1723                 type = ARDOUR::AudioUnit;
1724         } else if (prop->value() == X_("luaproc")) {
1725                 type = ARDOUR::Lua;
1726         } else {
1727                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1728                                   prop->value())
1729                       << endmsg;
1730                 return -1;
1731         }
1732
1733         prop = node.property ("unique-id");
1734
1735         if (prop == 0) {
1736 #ifdef WINDOWS_VST_SUPPORT
1737                 /* older sessions contain VST plugins with only an "id" field.
1738                  */
1739
1740                 if (type == ARDOUR::Windows_VST) {
1741                         prop = node.property ("id");
1742                 }
1743 #endif
1744
1745 #ifdef LXVST_SUPPORT
1746                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1747
1748                 if (type == ARDOUR::LXVST) {
1749                         prop = node.property ("id");
1750                 }
1751 #endif
1752                 /* recheck  */
1753
1754                 if (prop == 0) {
1755                         error << _("Plugin has no unique ID field") << endmsg;
1756                         return -1;
1757                 }
1758         }
1759
1760         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1761
1762         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1763          * allow to move sessions windows <> linux */
1764 #ifdef LXVST_SUPPORT
1765         if (plugin == 0 && type == ARDOUR::Windows_VST) {
1766                 type = ARDOUR::LXVST;
1767                 plugin = find_plugin (_session, prop->value(), type);
1768         }
1769 #endif
1770
1771 #ifdef WINDOWS_VST_SUPPORT
1772         if (plugin == 0 && type == ARDOUR::LXVST) {
1773                 type = ARDOUR::Windows_VST;
1774                 plugin = find_plugin (_session, prop->value(), type);
1775         }
1776 #endif
1777
1778         if (plugin == 0) {
1779                 error << string_compose(
1780                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1781                           "Perhaps it was removed or moved since it was last used."),
1782                         prop->value())
1783                       << endmsg;
1784                 return -1;
1785         }
1786
1787         if (type == ARDOUR::Lua) {
1788                 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1789                 // we need to load the script to set the name and parameters.
1790                 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1791                 if (ls && lp) {
1792                         lp->set_script_from_state (*ls);
1793                 }
1794         }
1795
1796         // The name of the PluginInsert comes from the plugin, nothing else
1797         _name = plugin->get_info()->name;
1798
1799         uint32_t count = 1;
1800
1801         // Processor::set_state() will set this, but too late
1802         // for it to be available when setting up plugin
1803         // state. We can't call Processor::set_state() until
1804         // the plugins themselves are created and added.
1805
1806         set_id (node);
1807
1808         if (_plugins.empty()) {
1809                 /* if we are adding the first plugin, we will need to set
1810                    up automatable controls.
1811                 */
1812                 add_plugin (plugin);
1813                 create_automatable_parameters ();
1814                 set_control_ids (node, version);
1815         }
1816
1817         if ((prop = node.property ("count")) != 0) {
1818                 sscanf (prop->value().c_str(), "%u", &count);
1819         }
1820
1821         if (_plugins.size() != count) {
1822                 for (uint32_t n = 1; n < count; ++n) {
1823                         add_plugin (plugin_factory (plugin));
1824                 }
1825         }
1826
1827         Processor::set_state (node, version);
1828
1829         PBD::ID new_id = this->id();
1830         PBD::ID old_id = this->id();
1831
1832         if ((prop = node.property ("id")) != 0) {
1833                 old_id = prop->value ();
1834         }
1835
1836         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1837
1838                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1839                    and set all plugins to the same state.
1840                 */
1841
1842                 if ((*niter)->name() == plugin->state_node_name()) {
1843
1844                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1845                                 /* Plugin state can include external files which are named after the ID.
1846                                  *
1847                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
1848                                  * been changed, so we need to use the old ID from the XML to load the
1849                                  * state and then update the ID.
1850                                  *
1851                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
1852                                  * but we need to call set_insert_id() to clear the cached plugin-state
1853                                  * and force a change.
1854                                  */
1855                                 if (!regenerate_xml_or_string_ids ()) {
1856                                         (*i)->set_insert_id (new_id);
1857                                 } else {
1858                                         (*i)->set_insert_id (old_id);
1859                                 }
1860
1861                                 (*i)->set_state (**niter, version);
1862
1863                                 if (regenerate_xml_or_string_ids ()) {
1864                                         (*i)->set_insert_id (new_id);
1865                                 }
1866                         }
1867
1868                         break;
1869                 }
1870         }
1871
1872         if (version < 3000) {
1873
1874                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1875                    this is all handled by Automatable
1876                 */
1877
1878                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1879                         if ((*niter)->name() == "Redirect") {
1880                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1881                                 Processor::set_state (**niter, version);
1882                                 break;
1883                         }
1884                 }
1885
1886                 set_parameter_state_2X (node, version);
1887         }
1888
1889         if ((prop = node.property (X_("custom"))) != 0) {
1890                 _custom_cfg = string_is_affirmative (prop->value());
1891         }
1892
1893         // TODO load/add sidechain
1894
1895         uint32_t in_maps = 0;
1896         uint32_t out_maps = 0;
1897         XMLNodeList kids = node.children ();
1898         for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
1899                 if ((*i)->name() == X_("ConfiguredOutput")) {
1900                         _custom_out = ChanCount(**i);
1901                 }
1902                 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
1903                         long pc = atol (&((*i)->name().c_str()[9]));
1904                         if (pc >=0 && pc <= get_count()) {
1905                                 _in_map[pc] = ChanMapping (**i);
1906                                 ++in_maps;
1907                         }
1908                 }
1909                 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
1910                         long pc = atol (&((*i)->name().c_str()[10]));
1911                         if (pc >=0 && pc <= get_count()) {
1912                                 _out_map[pc] = ChanMapping (**i);
1913                                 ++out_maps;
1914                         }
1915                 }
1916                 if ((*i)->name () ==  Processor::state_node_name) {
1917                         if (!_sidechain) {
1918                                 add_sidechain (0);
1919                         }
1920                         _sidechain->set_state (**i, version);
1921                 }
1922         }
1923
1924         if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
1925                 _maps_from_state = true;
1926         }
1927
1928         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1929                 if (active()) {
1930                         (*i)->activate ();
1931                 } else {
1932                         (*i)->deactivate ();
1933                 }
1934         }
1935
1936         return 0;
1937 }
1938
1939 void
1940 PluginInsert::update_id (PBD::ID id)
1941 {
1942         set_id (id.to_s());
1943         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1944                 (*i)->set_insert_id (id);
1945         }
1946 }
1947
1948 void
1949 PluginInsert::set_state_dir (const std::string& d)
1950 {
1951         // state() only saves the state of the first plugin
1952         _plugins[0]->set_state_dir (d);
1953 }
1954
1955 void
1956 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1957 {
1958         XMLNodeList nlist = node.children();
1959         XMLNodeIterator niter;
1960
1961         /* look for port automation node */
1962
1963         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1964
1965                 if ((*niter)->name() != port_automation_node_name) {
1966                         continue;
1967                 }
1968
1969                 XMLNodeList cnodes;
1970                 XMLProperty *cprop;
1971                 XMLNodeConstIterator iter;
1972                 XMLNode *child;
1973                 const char *port;
1974                 uint32_t port_id;
1975
1976                 cnodes = (*niter)->children ("port");
1977
1978                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1979
1980                         child = *iter;
1981
1982                         if ((cprop = child->property("number")) != 0) {
1983                                 port = cprop->value().c_str();
1984                         } else {
1985                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1986                                 continue;
1987                         }
1988
1989                         sscanf (port, "%" PRIu32, &port_id);
1990
1991                         if (port_id >= _plugins[0]->parameter_count()) {
1992                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1993                                 continue;
1994                         }
1995
1996                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1997                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1998
1999                         if (c && c->alist()) {
2000                                 if (!child->children().empty()) {
2001                                         c->alist()->set_state (*child->children().front(), version);
2002
2003                                         /* In some cases 2.X saves lists with min_yval and max_yval
2004                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
2005                                            in A3 because these min/max values are used to compute
2006                                            where GUI control points should be drawn.  If we see such
2007                                            values, `correct' them to the min/max of the appropriate
2008                                            parameter.
2009                                         */
2010
2011                                         float min_y = c->alist()->get_min_y ();
2012                                         float max_y = c->alist()->get_max_y ();
2013
2014                                         ParameterDescriptor desc;
2015                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
2016
2017                                         if (min_y == FLT_MIN) {
2018                                                 min_y = desc.lower;
2019                                         }
2020
2021                                         if (max_y == FLT_MAX) {
2022                                                 max_y = desc.upper;
2023                                         }
2024
2025                                         c->alist()->set_yrange (min_y, max_y);
2026                                 }
2027                         } else {
2028                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2029                         }
2030                 }
2031
2032                 /* done */
2033
2034                 break;
2035         }
2036 }
2037
2038
2039 string
2040 PluginInsert::describe_parameter (Evoral::Parameter param)
2041 {
2042         if (param.type() == PluginAutomation) {
2043                 return _plugins[0]->describe_parameter (param);
2044         } else if (param.type() == PluginPropertyAutomation) {
2045                 boost::shared_ptr<AutomationControl> c(automation_control(param));
2046                 if (c && !c->desc().label.empty()) {
2047                         return c->desc().label;
2048                 }
2049         }
2050         return Automatable::describe_parameter(param);
2051 }
2052
2053 ARDOUR::framecnt_t
2054 PluginInsert::signal_latency() const
2055 {
2056         if (_user_latency) {
2057                 return _user_latency;
2058         }
2059
2060         return _plugins[0]->signal_latency ();
2061 }
2062
2063 ARDOUR::PluginType
2064 PluginInsert::type ()
2065 {
2066        return plugin()->get_info()->type;
2067 }
2068
2069 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
2070                                             const Evoral::Parameter&          param,
2071                                             const ParameterDescriptor&        desc,
2072                                             boost::shared_ptr<AutomationList> list)
2073         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2074         , _plugin (p)
2075 {
2076         if (alist()) {
2077                 alist()->reset_default (desc.normal);
2078                 if (desc.toggled) {
2079                         list->set_interpolation(Evoral::ControlList::Discrete);
2080                 }
2081         }
2082
2083         if (desc.toggled) {
2084                 set_flags(Controllable::Toggle);
2085         }
2086 }
2087
2088 /** @param val `user' value */
2089 void
2090 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2091 {
2092         if (writable()) {
2093                 _set_value (user_val, group_override);
2094         }
2095 }
2096 void
2097 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2098 {
2099         /* used only by automation playback */
2100         _set_value (user_val, Controllable::NoGroup);
2101 }
2102
2103 void
2104 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2105 {
2106         /* FIXME: probably should be taking out some lock here.. */
2107
2108         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2109                 (*i)->set_parameter (_list->parameter().id(), user_val);
2110         }
2111
2112         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2113         if (iasp) {
2114                 iasp->set_parameter (_list->parameter().id(), user_val);
2115         }
2116
2117         AutomationControl::set_value (user_val, group_override);
2118 }
2119
2120 void
2121 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2122 {
2123         AutomationControl::set_value (user_val, Controllable::NoGroup);
2124 }
2125
2126 XMLNode&
2127 PluginInsert::PluginControl::get_state ()
2128 {
2129         stringstream ss;
2130
2131         XMLNode& node (AutomationControl::get_state());
2132         ss << parameter().id();
2133         node.add_property (X_("parameter"), ss.str());
2134 #ifdef LV2_SUPPORT
2135         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2136         if (lv2plugin) {
2137                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2138         }
2139 #endif
2140
2141         return node;
2142 }
2143
2144 /** @return `user' val */
2145 double
2146 PluginInsert::PluginControl::get_value () const
2147 {
2148         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2149
2150         if (!plugin) {
2151                 return 0.0;
2152         }
2153
2154         return plugin->get_parameter (_list->parameter().id());
2155 }
2156
2157 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
2158                                                             const Evoral::Parameter&          param,
2159                                                             const ParameterDescriptor&        desc,
2160                                                             boost::shared_ptr<AutomationList> list)
2161         : AutomationControl (p->session(), param, desc, list)
2162         , _plugin (p)
2163 {
2164         if (alist()) {
2165                 alist()->set_yrange (desc.lower, desc.upper);
2166                 alist()->reset_default (desc.normal);
2167         }
2168
2169         if (desc.toggled) {
2170                 set_flags(Controllable::Toggle);
2171         }
2172 }
2173
2174 void
2175 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2176 {
2177         if (writable()) {
2178                 set_value_unchecked (user_val);
2179         }
2180 }
2181
2182 void
2183 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2184 {
2185         /* Old numeric set_value(), coerce to appropriate datatype if possible.
2186            This is lossy, but better than nothing until Ardour's automation system
2187            can handle various datatypes all the way down. */
2188         const Variant value(_desc.datatype, user_val);
2189         if (value.type() == Variant::NOTHING) {
2190                 error << "set_value(double) called for non-numeric property" << endmsg;
2191                 return;
2192         }
2193
2194         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2195                 (*i)->set_property(_list->parameter().id(), value);
2196         }
2197
2198         _value = value;
2199         AutomationControl::set_value (user_val, Controllable::NoGroup);
2200 }
2201
2202 XMLNode&
2203 PluginInsert::PluginPropertyControl::get_state ()
2204 {
2205         stringstream ss;
2206
2207         XMLNode& node (AutomationControl::get_state());
2208         ss << parameter().id();
2209         node.add_property (X_("property"), ss.str());
2210         node.remove_property (X_("value"));
2211
2212         return node;
2213 }
2214
2215 double
2216 PluginInsert::PluginPropertyControl::get_value () const
2217 {
2218         return _value.to_double();
2219 }
2220
2221 boost::shared_ptr<Plugin>
2222 PluginInsert::get_impulse_analysis_plugin()
2223 {
2224         boost::shared_ptr<Plugin> ret;
2225         if (_impulseAnalysisPlugin.expired()) {
2226                 ret = plugin_factory(_plugins[0]);
2227                 ret->configure_io (internal_input_streams (), internal_output_streams ());
2228                 _impulseAnalysisPlugin = ret;
2229         } else {
2230                 ret = _impulseAnalysisPlugin.lock();
2231         }
2232
2233         return ret;
2234 }
2235
2236 void
2237 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2238 {
2239         // called from outside the audio thread, so this should be safe
2240         // only do audio as analysis is (currently) only for audio plugins
2241         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, internal_input_streams().n_audio(),  nframes);
2242         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2243
2244         _signal_analysis_collected_nframes   = 0;
2245         _signal_analysis_collect_nframes_max = nframes;
2246 }
2247
2248 /** Add a plugin to our list */
2249 void
2250 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2251 {
2252         plugin->set_insert_id (this->id());
2253
2254         if (_plugins.empty()) {
2255                 /* first (and probably only) plugin instance - connect to relevant signals */
2256
2257                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2258                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2259                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2260                 // cache sidechain ports
2261                 _cached_sidechain_pins.reset ();
2262                 const ChanCount& nis (plugin->get_info()->n_inputs);
2263                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2264                         for (uint32_t in = 0; in < nis.get (*t); ++in) {
2265                                 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2266                                 if (iod.is_sidechain) {
2267                                         _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2268                                 }
2269                         }
2270                 }
2271         }
2272         _plugins.push_back (plugin);
2273 }
2274
2275 void
2276 PluginInsert::realtime_handle_transport_stopped ()
2277 {
2278         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2279                 (*i)->realtime_handle_transport_stopped ();
2280         }
2281 }
2282
2283 void
2284 PluginInsert::realtime_locate ()
2285 {
2286         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2287                 (*i)->realtime_locate ();
2288         }
2289 }
2290
2291 void
2292 PluginInsert::monitoring_changed ()
2293 {
2294         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2295                 (*i)->monitoring_changed ();
2296         }
2297 }
2298
2299 void
2300 PluginInsert::start_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->start_touch (session().audible_frame());
2305         }
2306 }
2307
2308 void
2309 PluginInsert::end_touch (uint32_t param_id)
2310 {
2311         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2312         if (ac) {
2313                 ac->stop_touch (true, session().audible_frame());
2314         }
2315 }
2316
2317 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2318 {
2319         switch (m.method) {
2320                 case PluginInsert::Impossible: o << "Impossible"; break;
2321                 case PluginInsert::Delegate:   o << "Delegate"; break;
2322                 case PluginInsert::NoInputs:   o << "NoInputs"; break;
2323                 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2324                 case PluginInsert::Replicate:  o << "Replicate"; break;
2325                 case PluginInsert::Split:      o << "Split"; break;
2326                 case PluginInsert::Hide:       o << "Hide"; break;
2327         }
2328         o << " cnt: " << m.plugins
2329                 << (m.strict_io ? " strict-io" : "")
2330                 << (m.custom_cfg ? " custom-cfg" : "");
2331         if (m.method == PluginInsert::Hide) {
2332                 o << " hide: " << m.hide;
2333         }
2334         o << "\n";
2335         return o;
2336 }