libs/ardour/plugin_insert.cc

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