libs/ardour/plugin_insert.cc

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