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