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         , _no_inplace (false)
  72         , _pending_no_inplace (false)
  73         , _strict_io (false)
  74         , _strict_io_configured (false)
  75 {
  76         /* the first is the master */
  77
  78         if (plug) {
  79                 add_plugin (plug);
  80                 create_automatable_parameters ();
  81         }
  82 }
  83
  84 bool
  85 PluginInsert::set_count (uint32_t num)
  86 {
  87         bool require_state = !_plugins.empty();
  88
  89         /* this is a bad idea.... we shouldn't do this while active.
  90            only a route holding their redirect_lock should be calling this
  91         */
  92
  93         if (num == 0) {
  94                 return false;
  95         } else if (num > _plugins.size()) {
  96                 uint32_t diff = num - _plugins.size();
  97
  98                 for (uint32_t n = 0; n < diff; ++n) {
  99                         boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
 100                         add_plugin (p);
 101                         if (active ()) {
 102                                 p->activate ();
 103                         }
 104
 105                         if (require_state) {
 106                                 /* XXX do something */
 107                         }
 108                 }
 109
 110         } else if (num < _plugins.size()) {
 111                 uint32_t diff = _plugins.size() - num;
 112                 for (uint32_t n= 0; n < diff; ++n) {
 113                         _plugins.pop_back();
 114                 }
 115         }
 116
 117         return true;
 118 }
 119
 120 PluginInsert::~PluginInsert ()
 121 {
 122 }
 123
 124 void
 125 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
 126 {
 127         if (which.type() != PluginAutomation)
 128                 return;
 129
 130         boost::shared_ptr<AutomationControl> c
 131                         = boost::dynamic_pointer_cast<AutomationControl>(control (which));
 132
 133         if (c && s != Off) {
 134                 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
 135         }
 136 }
 137
 138 ChanCount
 139 PluginInsert::output_streams() const
 140 {
 141         assert (!_plugins.empty());
 142
 143         PluginInfoPtr info = _plugins.front()->get_info();
 144
 145         if (_strict_io_configured) {
 146                 return _configured_in; // XXX, check initial configuration
 147         }
 148         else if (info->reconfigurable_io()) {
 149                 ChanCount out = _plugins.front()->output_streams ();
 150                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
 151                 return out;
 152         } else {
 153                 ChanCount out = info->n_outputs;
 154                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
 155                 out.set_audio (out.n_audio() * _plugins.size());
 156                 out.set_midi (out.n_midi() * _plugins.size() + midi_bypass.n_midi());
 157                 return out;
 158         }
 159 }
 160
 161 ChanCount
 162 PluginInsert::input_streams() const
 163 {
 164         assert (!_plugins.empty());
 165
 166         ChanCount in;
 167
 168         PluginInfoPtr info = _plugins.front()->get_info();
 169
 170         if (info->reconfigurable_io()) {
 171                 assert (_plugins.size() == 1);
 172                 in = _plugins.front()->input_streams();
 173         } else {
 174                 in = info->n_inputs;
 175         }
 176
 177         DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
 178
 179         if (_match.method == Split) {
 180
 181                 /* we are splitting 1 processor input to multiple plugin inputs,
 182                    so we have a maximum of 1 stream of each type.
 183                 */
 184                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 185                         if (in.get (*t) > 1) {
 186                                 in.set (*t, 1);
 187                         }
 188                 }
 189                 return in;
 190
 191         } else if (_match.method == Hide) {
 192
 193                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 194                         in.set (*t, in.get (*t) - _match.hide.get (*t));
 195                 }
 196                 return in;
 197
 198         } else {
 199
 200                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 201                         in.set (*t, in.get (*t) * _plugins.size ());
 202                 }
 203
 204                 return in;
 205         }
 206 }
 207
 208 ChanCount
 209 PluginInsert::natural_output_streams() const
 210 {
 211         return _plugins[0]->get_info()->n_outputs;
 212 }
 213
 214 ChanCount
 215 PluginInsert::natural_input_streams() const
 216 {
 217         return _plugins[0]->get_info()->n_inputs;
 218 }
 219
 220 bool
 221 PluginInsert::has_no_inputs() const
 222 {
 223         return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
 224 }
 225
 226 bool
 227 PluginInsert::has_no_audio_inputs() const
 228 {
 229         return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
 230 }
 231
 232 bool
 233 PluginInsert::is_midi_instrument() const
 234 {
 235         /* XXX more finesse is possible here. VST plugins have a
 236            a specific "instrument" flag, for example.
 237          */
 238         PluginInfoPtr pi = _plugins[0]->get_info();
 239
 240         return pi->n_inputs.n_midi() != 0 &&
 241                 pi->n_outputs.n_audio() > 0;
 242 }
 243
 244 void
 245 PluginInsert::create_automatable_parameters ()
 246 {
 247         assert (!_plugins.empty());
 248
 249         set<Evoral::Parameter> a = _plugins.front()->automatable ();
 250
 251         for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
 252                 if (i->type() == PluginAutomation) {
 253
 254                         Evoral::Parameter param(*i);
 255
 256                         ParameterDescriptor desc;
 257                         _plugins.front()->get_parameter_descriptor(i->id(), desc);
 258
 259                         can_automate (param);
 260                         boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
 261                         boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
 262                         add_control (c);
 263                         _plugins.front()->set_automation_control (i->id(), c);
 264                 } else if (i->type() == PluginPropertyAutomation) {
 265                         Evoral::Parameter param(*i);
 266                         const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
 267                         if (desc.datatype != Variant::NOTHING) {
 268                                 boost::shared_ptr<AutomationList> list;
 269                                 if (Variant::type_is_numeric(desc.datatype)) {
 270                                         list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
 271                                 }
 272                                 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
 273                         }
 274                 }
 275         }
 276 }
 277 /** Called when something outside of this host has modified a plugin
 278  * parameter. Responsible for propagating the change to two places:
 279  *
 280  *   1) anything listening to the Control itself
 281  *   2) any replicated plugins that make up this PluginInsert.
 282  *
 283  * The PluginInsert is connected to the ParameterChangedExternally signal for
 284  * the first (primary) plugin, and here broadcasts that change to any others.
 285  *
 286  * XXX We should probably drop this whole replication idea (Paul, October 2015)
 287  * since it isn't used by sensible plugin APIs (AU, LV2).
 288  */
 289 void
 290 PluginInsert::parameter_changed_externally (uint32_t which, float val)
 291 {
 292         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
 293
 294         /* First propagation: alter the underlying value of the control,
 295          * without telling the plugin(s) that own/use it to set it.
 296          */
 297
 298         if (!ac) {
 299                 return;
 300         }
 301
 302         boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
 303
 304         if (pc) {
 305                 pc->catch_up_with_external_value (val);
 306         }
 307
 308         /* Second propagation: tell all plugins except the first to
 309            update the value of this parameter. For sane plugin APIs,
 310            there are no other plugins, so this is a no-op in those
 311            cases.
 312         */
 313
 314         Plugins::iterator i = _plugins.begin();
 315
 316         /* don't set the first plugin, just all the slaves */
 317
 318         if (i != _plugins.end()) {
 319                 ++i;
 320                 for (; i != _plugins.end(); ++i) {
 321                         (*i)->set_parameter (which, val);
 322                 }
 323         }
 324 }
 325
 326 int
 327 PluginInsert::set_block_size (pframes_t nframes)
 328 {
 329         int ret = 0;
 330         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 331                 if ((*i)->set_block_size (nframes) != 0) {
 332                         ret = -1;
 333                 }
 334         }
 335         return ret;
 336 }
 337
 338 void
 339 PluginInsert::activate ()
 340 {
 341         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 342                 (*i)->activate ();
 343         }
 344
 345         Processor::activate ();
 346 }
 347
 348 void
 349 PluginInsert::deactivate ()
 350 {
 351         Processor::deactivate ();
 352
 353         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 354                 (*i)->deactivate ();
 355         }
 356 }
 357
 358 void
 359 PluginInsert::flush ()
 360 {
 361         for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 362                 (*i)->flush ();
 363         }
 364 }
 365
 366 void
 367 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
 368 {
 369         _no_inplace = _pending_no_inplace;
 370         // Calculate if, and how many frames we need to collect for analysis
 371         framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
 372                                              _signal_analysis_collected_nframes);
 373         if (nframes < collect_signal_nframes) { // we might not get all frames now
 374                 collect_signal_nframes = nframes;
 375         }
 376
 377         ChanCount const in_streams = input_streams ();
 378         ChanCount const out_streams = output_streams ();
 379
 380         if (_match.method == Split) {
 381                 assert (_in_map.size () == 1);
 382                 /* fix the input mapping so that we have maps for each of the plugin's inputs */
 383
 384                 /* copy the first stream's buffer contents to the others */
 385                 /* XXX: audio only */
 386                 bool valid;
 387                 uint32_t first_idx = _in_map[0].get (DataType::AUDIO, 0, &valid);
 388                 if (valid) {
 389                         for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
 390                                 bufs.get_audio(_in_map[0].get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
 391                         }
 392                 }
 393         }
 394
 395         bufs.set_count(ChanCount::max(bufs.count(), in_streams));
 396         bufs.set_count(ChanCount::max(bufs.count(), out_streams));
 397
 398         /* Note that we've already required that plugins
 399            be able to handle in-place processing.
 400         */
 401
 402         if (with_auto) {
 403
 404                 uint32_t n = 0;
 405
 406                 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
 407
 408                         boost::shared_ptr<AutomationControl> c
 409                                 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
 410
 411                         if (c->list() && c->automation_playback()) {
 412                                 bool valid;
 413
 414                                 const float val = c->list()->rt_safe_eval (now, valid);
 415
 416                                 if (valid) {
 417                                         /* This is the ONLY place where we are
 418                                          *  allowed to call
 419                                          *  AutomationControl::set_value_unchecked(). We
 420                                          *  know that the control is in
 421                                          *  automation playback mode, so no
 422                                          *  check on writable() is required
 423                                          *  (which must be done in AutomationControl::set_value()
 424                                          *
 425                                          */
 426                                         c->set_value_unchecked(val);
 427                                 }
 428
 429                         }
 430                 }
 431         }
 432
 433         if (collect_signal_nframes > 0) {
 434                 // collect input
 435                 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 436                 //std::cerr << "               streams " << input_streams().n_audio() << std::endl;
 437                 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
 438
 439                 _signal_analysis_inputs.set_count(input_streams());
 440
 441                 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
 442                         _signal_analysis_inputs.get_audio(i).read_from(
 443                                 bufs.get_audio(i),
 444                                 collect_signal_nframes,
 445                                 _signal_analysis_collected_nframes); // offset is for target buffer
 446                 }
 447
 448         }
 449
 450         if (_no_inplace) {
 451                 BufferSet& inplace_bufs  = _session.get_noinplace_buffers();
 452                 ARDOUR::ChanMapping used_outputs;
 453
 454                 uint32_t pc = 0;
 455                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
 456
 457                         ARDOUR::ChanMapping in_map (natural_input_streams());
 458                         ARDOUR::ChanMapping out_map;
 459                         ARDOUR::ChanCount mapped;
 460                         ARDOUR::ChanCount backmap;
 461
 462                         // map inputs sequentially
 463                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 464                                 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
 465                                         bool valid;
 466                                         uint32_t in_idx = _in_map[pc].get (*t, in, &valid);
 467                                         uint32_t m = mapped.get (*t);
 468                                         if (valid) {
 469                                                 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
 470                                         } else {
 471                                                 inplace_bufs.get (*t, m).silence (nframes, offset);
 472                                         }
 473                                         mapped.set (*t, m + 1);
 474                                 }
 475                         }
 476
 477                         // TODO use map_offset_to()  instead ??
 478                         backmap = mapped;
 479
 480                         // map outputs
 481                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 482                                 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
 483                                         uint32_t m = mapped.get (*t);
 484                                         inplace_bufs.get (*t, m).silence (nframes, offset);
 485                                         out_map.set (*t, out, m);
 486                                         mapped.set (*t, m + 1);
 487                                 }
 488                         }
 489
 490                         if ((*i)->connect_and_run(inplace_bufs, in_map, out_map, nframes, offset)) {
 491                                 deactivate ();
 492                         }
 493
 494
 495                         // copy back outputs
 496                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 497                                 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
 498                                         uint32_t m = backmap.get (*t);
 499                                         bool valid;
 500                                         uint32_t out_idx = _out_map[pc].get (*t, out, &valid);
 501                                         if (valid) {
 502                                                 bufs.get (*t, out_idx).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
 503                                                 used_outputs.set (*t, out_idx, 1); // mark as used
 504                                         }
 505                                         backmap.set (*t, m + 1);
 506                                 }
 507                         }
 508                 }
 509                 /* all instances have completed, now clear outputs that have not been written to.
 510                  * (except midi bypass)
 511                  */
 512                 if (bufs.count().n_midi() == 1 && natural_output_streams().get(DataType::MIDI) == 0) {
 513                         used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
 514                 }
 515                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 516                         for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
 517                                 bool valid;
 518                                 used_outputs.get (*t, out, &valid);
 519                                 if (valid) { continue; }
 520                                 bufs.get (*t, out).silence (nframes, offset);
 521                         }
 522                 }
 523
 524         } else {
 525                 uint32_t pc = 0;
 526                 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
 527                         if ((*i)->connect_and_run(bufs, _in_map[pc], _out_map[pc], nframes, offset)) {
 528                                 deactivate ();
 529                         }
 530                 }
 531         }
 532
 533         if (collect_signal_nframes > 0) {
 534                 // collect output
 535                 //std::cerr << "       output, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 536                 //std::cerr << "               streams " << output_streams().n_audio() << std::endl;
 537
 538                 _signal_analysis_outputs.set_count(output_streams());
 539
 540                 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
 541                         _signal_analysis_outputs.get_audio(i).read_from(
 542                                 bufs.get_audio(i),
 543                                 collect_signal_nframes,
 544                                 _signal_analysis_collected_nframes); // offset is for target buffer
 545                 }
 546
 547                 _signal_analysis_collected_nframes += collect_signal_nframes;
 548                 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
 549
 550                 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
 551                         _signal_analysis_collect_nframes_max = 0;
 552                         _signal_analysis_collected_nframes   = 0;
 553
 554                         AnalysisDataGathered(&_signal_analysis_inputs,
 555                                              &_signal_analysis_outputs);
 556                 }
 557         }
 558         /* leave remaining channel buffers alone */
 559 }
 560
 561 void
 562 PluginInsert::silence (framecnt_t nframes)
 563 {
 564         if (!active ()) {
 565                 return;
 566         }
 567
 568         ChanMapping in_map (natural_input_streams ());
 569         ChanMapping out_map (natural_output_streams ());
 570
 571         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 572                 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
 573         }
 574 }
 575
 576 void
 577 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
 578 {
 579         if (_pending_active) {
 580                 /* run as normal if we are active or moving from inactive to active */
 581
 582                 if (_session.transport_rolling() || _session.bounce_processing()) {
 583                         automation_run (bufs, start_frame, nframes);
 584                 } else {
 585                         connect_and_run (bufs, nframes, 0, false);
 586                 }
 587
 588         } else {
 589                 uint32_t in = input_streams ().n_audio ();
 590                 uint32_t out = output_streams().n_audio ();
 591
 592                 if (has_no_audio_inputs() || in == 0) {
 593
 594                         /* silence all (audio) outputs. Should really declick
 595                          * at the transitions of "active"
 596                          */
 597
 598                         for (uint32_t n = 0; n < out; ++n) {
 599                                 bufs.get_audio (n).silence (nframes);
 600                         }
 601
 602                 } else if (out > in) {
 603
 604                         /* not active, but something has make up for any channel count increase */
 605
 606                         // TODO: option round-robin (n % in) or silence additional buffers ??
 607                         // for now , simply replicate last buffer
 608                         for (uint32_t n = in; n < out; ++n) {
 609                                 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
 610                         }
 611                 }
 612
 613                 bufs.count().set_audio (out);
 614         }
 615
 616         _active = _pending_active;
 617
 618         /* we have no idea whether the plugin generated silence or not, so mark
 619          * all buffers appropriately.
 620          */
 621
 622 }
 623
 624 void
 625 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
 626 {
 627         Evoral::ControlEvent next_event (0, 0.0f);
 628         framepos_t now = start;
 629         framepos_t end = now + nframes;
 630         framecnt_t offset = 0;
 631
 632         Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
 633
 634         if (!lm.locked()) {
 635                 connect_and_run (bufs, nframes, offset, false);
 636                 return;
 637         }
 638
 639         if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
 640
 641                 /* no events have a time within the relevant range */
 642
 643                 connect_and_run (bufs, nframes, offset, true, now);
 644                 return;
 645         }
 646
 647         while (nframes) {
 648
 649                 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
 650
 651                 connect_and_run (bufs, cnt, offset, true, now);
 652
 653                 nframes -= cnt;
 654                 offset += cnt;
 655                 now += cnt;
 656
 657                 if (!find_next_event (now, end, next_event)) {
 658                         break;
 659                 }
 660         }
 661
 662         /* cleanup anything that is left to do */
 663
 664         if (nframes) {
 665                 connect_and_run (bufs, nframes, offset, true, now);
 666         }
 667 }
 668
 669 float
 670 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
 671 {
 672         if (param.type() != PluginAutomation)
 673                 return 1.0;
 674
 675         if (_plugins.empty()) {
 676                 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
 677                       << endmsg;
 678                 abort(); /*NOTREACHED*/
 679         }
 680
 681         return _plugins[0]->default_value (param.id());
 682 }
 683
 684
 685 bool
 686 PluginInsert::can_reset_all_parameters ()
 687 {
 688         bool all = true;
 689         uint32_t params = 0;
 690         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 691                 bool ok=false;
 692                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 693
 694                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 695                         continue;
 696                 }
 697
 698                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 699                 if (!ac) {
 700                         continue;
 701                 }
 702
 703                 ++params;
 704                 if (ac->automation_state() & Play) {
 705                         all = false;
 706                         break;
 707                 }
 708         }
 709         return all && (params > 0);
 710 }
 711
 712 bool
 713 PluginInsert::reset_parameters_to_default ()
 714 {
 715         bool all = true;
 716
 717         for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
 718                 bool ok=false;
 719                 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
 720
 721                 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
 722                         continue;
 723                 }
 724
 725                 const float dflt = _plugins[0]->default_value (cid);
 726                 const float curr = _plugins[0]->get_parameter (cid);
 727
 728                 if (dflt == curr) {
 729                         continue;
 730                 }
 731
 732                 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
 733                 if (!ac) {
 734                         continue;
 735                 }
 736
 737                 if (ac->automation_state() & Play) {
 738                         all = false;
 739                         continue;
 740                 }
 741
 742                 ac->set_value (dflt, Controllable::NoGroup);
 743         }
 744         return all;
 745 }
 746
 747 boost::shared_ptr<Plugin>
 748 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
 749 {
 750         boost::shared_ptr<LadspaPlugin> lp;
 751         boost::shared_ptr<LuaProc> lua;
 752 #ifdef LV2_SUPPORT
 753         boost::shared_ptr<LV2Plugin> lv2p;
 754 #endif
 755 #ifdef WINDOWS_VST_SUPPORT
 756         boost::shared_ptr<WindowsVSTPlugin> vp;
 757 #endif
 758 #ifdef LXVST_SUPPORT
 759         boost::shared_ptr<LXVSTPlugin> lxvp;
 760 #endif
 761 #ifdef AUDIOUNIT_SUPPORT
 762         boost::shared_ptr<AUPlugin> ap;
 763 #endif
 764
 765         if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
 766                 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
 767         } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
 768                 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
 769 #ifdef LV2_SUPPORT
 770         } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
 771                 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
 772 #endif
 773 #ifdef WINDOWS_VST_SUPPORT
 774         } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
 775                 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
 776 #endif
 777 #ifdef LXVST_SUPPORT
 778         } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
 779                 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
 780 #endif
 781 #ifdef AUDIOUNIT_SUPPORT
 782         } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
 783                 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
 784 #endif
 785         }
 786
 787         fatal << string_compose (_("programming error: %1"),
 788                           X_("unknown plugin type in PluginInsert::plugin_factory"))
 789               << endmsg;
 790         abort(); /*NOTREACHED*/
 791         return boost::shared_ptr<Plugin> ((Plugin*) 0);
 792 }
 793
 794 bool
 795 PluginInsert::configure_io (ChanCount in, ChanCount out)
 796 {
 797         Match old_match = _match;
 798         ChanCount old_in = input_streams ();
 799         ChanCount old_out = output_streams ();
 800
 801         _configured_in = in;
 802         _configured_out = out;
 803
 804         /* TODO use "custom config"
 805          * allow user to edit/override output ports, handle strict i/o.
 806          *
 807          * configuration should only applied here.
 808          */
 809
 810         /* set the matching method and number of plugins that we will use to meet this configuration */
 811         _match = private_can_support_io_configuration (in, out);
 812         if (set_count (_match.plugins) == false) {
 813                 PluginIoReConfigure (); /* EMIT SIGNAL */
 814                 return false;
 815         }
 816
 817         /* configure plugins */
 818         switch (_match.method) {
 819         case Split:
 820         case Hide:
 821                 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out) == false) {
 822                         PluginIoReConfigure (); /* EMIT SIGNAL */
 823                         return false;
 824                 }
 825                 break;
 826
 827         default:
 828                 if (_plugins.front()->configure_io (in, out) == false) {
 829                         PluginIoReConfigure (); /* EMIT SIGNAL */
 830                         return false;
 831                 }
 832                 break;
 833         }
 834
 835         // TODO make configurable, ideally use a single in/out map for all replicated
 836         // plugins.
 837         uint32_t pc = 0;
 838         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
 839                 if (_match.method == Split) {
 840                         /* TODO see PluginInsert::connect_and_run, channel replication */
 841                         _in_map[pc] = ChanMapping (natural_input_streams ());
 842                 } else {
 843                         _in_map[pc] = ChanMapping (input_streams ());
 844                 }
 845                 _out_map[pc] = ChanMapping (output_streams());
 846
 847                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 848                         _in_map[pc].offset_to(*t, pc * natural_input_streams().get(*t));
 849                         _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
 850                 }
 851         }
 852
 853
 854         if (  (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
 855                         || old_in != in
 856                         || old_out != out
 857                         )
 858         {
 859                 PluginIoReConfigure (); /* EMIT SIGNAL */
 860         }
 861
 862         // we don't know the analysis window size, so we must work with the
 863         // current buffer size here. each request for data fills in these
 864         // buffers and the analyser makes sure it gets enough data for the
 865         // analysis window
 866         session().ensure_buffer_set (_signal_analysis_inputs, in);
 867         //_signal_analysis_inputs.set_count (in);
 868
 869         session().ensure_buffer_set (_signal_analysis_outputs, out);
 870         //_signal_analysis_outputs.set_count (out);
 871
 872         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
 873
 874         return Processor::configure_io (in, out);
 875 }
 876
 877 /** Decide whether this PluginInsert can support a given IO configuration.
 878  *  To do this, we run through a set of possible solutions in rough order of
 879  *  preference.
 880  *
 881  *  @param in Required input channel count.
 882  *  @param out Filled in with the output channel count if we return true.
 883  *  @return true if the given IO configuration can be supported.
 884  */
 885 bool
 886 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 887 {
 888         return private_can_support_io_configuration (in, out).method != Impossible;
 889 }
 890
 891 /** A private version of can_support_io_configuration which returns the method
 892  *  by which the configuration can be matched, rather than just whether or not
 893  *  it can be.
 894  */
 895 PluginInsert::Match
 896 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
 897 {
 898         _strict_io_configured = false;
 899         if (_plugins.empty()) {
 900                 return Match();
 901         }
 902
 903         PluginInfoPtr info = _plugins.front()->get_info();
 904         ChanCount in; in += inx;
 905         midi_bypass.reset();
 906
 907         if (info->reconfigurable_io()) {
 908                 /* Plugin has flexible I/O, so delegate to it */
 909                 bool const r = _plugins.front()->can_support_io_configuration (in, out);
 910                 if (!r) {
 911                         return Match (Impossible, 0);
 912                 }
 913
 914                 if (_strict_io && in.n_audio() < out.n_audio()) {
 915                         DEBUG_TRACE (DEBUG::Processors, string_compose ("hiding output ports of reconfigurable %1\n", name()));
 916                         out.set (DataType::AUDIO, in.get (DataType::AUDIO));
 917                 }
 918
 919                 return Match (Delegate, 1);
 920         }
 921
 922         ChanCount inputs  = info->n_inputs;
 923         ChanCount outputs = info->n_outputs;
 924
 925         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
 926                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
 927                 midi_bypass.set(DataType::MIDI, 1);
 928         }
 929         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
 930                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
 931                 in.set(DataType::MIDI, 0);
 932         }
 933
 934         bool no_inputs = true;
 935         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 936                 if (inputs.get (*t) != 0) {
 937                         no_inputs = false;
 938                         break;
 939                 }
 940         }
 941
 942         /* replicate no-input generators with strict i/o */
 943         if (no_inputs && _strict_io) {
 944                 uint32_t f             = 0;
 945                 bool     can_replicate = true;
 946
 947                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 948                         uint32_t nout = outputs.get (*t);
 949                         uint32_t nwant = in.get (*t);
 950                         if (nout > nwant) {
 951                                 can_replicate = false;
 952                                 break;
 953                         }
 954                         if (nout == nwant) {
 955                                 continue;
 956                         }
 957
 958                         if (f == 0 && nwant % nout == 0) {
 959                                 f = nwant / nout;
 960                         }
 961
 962                         if (f * nout != nwant) {
 963                                 can_replicate = false;
 964                                 break;
 965                         }
 966                 }
 967
 968                 if (can_replicate && f > 1) {
 969                         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 970                                 out.set (*t, outputs.get(*t) * f);
 971                         }
 972                         out += midi_bypass;
 973                         return Match (Replicate, f);
 974                 }
 975         }
 976
 977         if ((no_inputs || inputs == in) && _strict_io) {
 978                 /* special case synths and generators */
 979                 if (in.n_audio () == 0 && in.n_midi () > 0 && outputs.n_audio () > 0) {
 980                         // TODO limit the audio-channel count to track output
 981                         out = outputs + midi_bypass;
 982                 } else {
 983                         _strict_io_configured = true;
 984                         out = in + midi_bypass;
 985                 }
 986                 return Match (ExactMatch, 1);
 987         }
 988
 989         if (no_inputs) {
 990                 /* no inputs so we can take any input configuration since we throw it away */
 991                 out = outputs + midi_bypass;
 992                 return Match (NoInputs, 1);
 993         }
 994
 995         /* Plugin inputs match requested inputs exactly */
 996         if (inputs == in) {
 997                 out = outputs + midi_bypass;
 998                 return Match (ExactMatch, 1);
 999         }
1000
1001         /* We may be able to run more than one copy of the plugin within this insert
1002            to cope with the insert having more inputs than the plugin.
1003            We allow replication only for plugins with either zero or 1 inputs and outputs
1004            for every valid data type.
1005         */
1006
1007         uint32_t f             = 0;
1008         bool     can_replicate = true;
1009         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1010
1011                 uint32_t nin = inputs.get (*t);
1012
1013                 // No inputs of this type
1014                 if (nin == 0 && in.get(*t) == 0) {
1015                         continue;
1016                 }
1017
1018                 if (nin != 1 || outputs.get (*t) != 1) {
1019                         can_replicate = false;
1020                         break;
1021                 }
1022
1023                 // Potential factor not set yet
1024                 if (f == 0) {
1025                         f = in.get(*t) / nin;
1026                 }
1027
1028                 // Factor for this type does not match another type, can not replicate
1029                 if (f != (in.get(*t) / nin)) {
1030                         can_replicate = false;
1031                         break;
1032                 }
1033         }
1034
1035         if (can_replicate) {
1036                 assert (f > 1);
1037                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1038                         out.set (*t, outputs.get(*t) * f);
1039                 }
1040                 out += midi_bypass;
1041                 return Match (Replicate, f);
1042         }
1043
1044         /* If the processor has exactly one input of a given type, and
1045            the plugin has more, we can feed the single processor input
1046            to some or all of the plugin inputs.  This is rather
1047            special-case-y, but the 1-to-many case is by far the
1048            simplest.  How do I split thy 2 processor inputs to 3
1049            plugin inputs?  Let me count the ways ...
1050         */
1051
1052         bool can_split = !_strict_io;
1053         for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_split; ++t) {
1054
1055                 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
1056                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1057
1058                 if (!can_split_type && !nothing_to_do_for_type) {
1059                         can_split = false;
1060                 }
1061         }
1062
1063         if (can_split) {
1064                 out = outputs + midi_bypass;
1065                 return Match (Split, 1);
1066         }
1067
1068         /* If the plugin has more inputs than we want, we can `hide' some of them
1069            by feeding them silence.
1070         */
1071
1072         bool could_hide = false;
1073         bool cannot_hide = false;
1074         ChanCount hide_channels;
1075
1076         for (DataType::iterator t = DataType::begin(); t != DataType::end() && !cannot_hide; ++t) {
1077                 if (inputs.get(*t) > in.get(*t)) {
1078                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1079                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1080                         could_hide = true;
1081                 } else if (inputs.get(*t) < in.get(*t)) {
1082                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1083                         cannot_hide = true;
1084                 }
1085         }
1086
1087         if (could_hide && !cannot_hide) {
1088                 if (_strict_io /*&& inputs.get (DataType::AUDIO) == outputs.get (DataType::AUDIO)*/) {
1089                         _strict_io_configured = true;
1090                         outputs = inputs;
1091                 } else {
1092                         out = outputs + midi_bypass;
1093                 }
1094                 return Match (Hide, 1, hide_channels);
1095         }
1096
1097         midi_bypass.reset();
1098         // TODO make it possible :)
1099         return Match (Impossible, 0);
1100 }
1101
1102 XMLNode&
1103 PluginInsert::get_state ()
1104 {
1105         return state (true);
1106 }
1107
1108 XMLNode&
1109 PluginInsert::state (bool full)
1110 {
1111         XMLNode& node = Processor::state (full);
1112
1113         node.add_property("type", _plugins[0]->state_node_name());
1114         node.add_property("unique-id", _plugins[0]->unique_id());
1115         node.add_property("count", string_compose("%1", _plugins.size()));
1116
1117         /* remember actual i/o configuration (for later placeholder
1118          * in case the plugin goes missing) */
1119         node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1120         node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1121
1122         _plugins[0]->set_insert_id(this->id());
1123         node.add_child_nocopy (_plugins[0]->get_state());
1124
1125         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1126                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1127                 if (ac) {
1128                         node.add_child_nocopy (ac->get_state());
1129                 }
1130         }
1131
1132         return node;
1133 }
1134
1135 void
1136 PluginInsert::set_control_ids (const XMLNode& node, int version)
1137 {
1138         const XMLNodeList& nlist = node.children();
1139         XMLNodeConstIterator iter;
1140         set<Evoral::Parameter>::const_iterator p;
1141
1142         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1143                 if ((*iter)->name() == Controllable::xml_node_name) {
1144                         const XMLProperty* prop;
1145
1146                         uint32_t p = (uint32_t)-1;
1147 #ifdef LV2_SUPPORT
1148                         if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1149                                 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1150                                 if (lv2plugin) {
1151                                         p = lv2plugin->port_index(prop->value().c_str());
1152                                 }
1153                         }
1154 #endif
1155                         if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1156                                 p = atoi (prop->value());
1157                         }
1158
1159                         if (p != (uint32_t)-1) {
1160
1161                                 /* this may create the new controllable */
1162
1163                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1164
1165 #ifndef NO_PLUGIN_STATE
1166                                 if (!c) {
1167                                         continue;
1168                                 }
1169                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1170                                 if (ac) {
1171                                         ac->set_state (**iter, version);
1172                                 }
1173 #endif
1174                         }
1175                 }
1176         }
1177 }
1178
1179 int
1180 PluginInsert::set_state(const XMLNode& node, int version)
1181 {
1182         XMLNodeList nlist = node.children();
1183         XMLNodeIterator niter;
1184         XMLPropertyList plist;
1185         const XMLProperty *prop;
1186         ARDOUR::PluginType type;
1187
1188         if ((prop = node.property ("type")) == 0) {
1189                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1190                 return -1;
1191         }
1192
1193         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1194                 type = ARDOUR::LADSPA;
1195         } else if (prop->value() == X_("lv2")) {
1196                 type = ARDOUR::LV2;
1197         } else if (prop->value() == X_("windows-vst")) {
1198                 type = ARDOUR::Windows_VST;
1199         } else if (prop->value() == X_("lxvst")) {
1200                 type = ARDOUR::LXVST;
1201         } else if (prop->value() == X_("audiounit")) {
1202                 type = ARDOUR::AudioUnit;
1203         } else if (prop->value() == X_("luaproc")) {
1204                 type = ARDOUR::Lua;
1205         } else {
1206                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1207                                   prop->value())
1208                       << endmsg;
1209                 return -1;
1210         }
1211
1212         prop = node.property ("unique-id");
1213
1214         if (prop == 0) {
1215 #ifdef WINDOWS_VST_SUPPORT
1216                 /* older sessions contain VST plugins with only an "id" field.
1217                  */
1218
1219                 if (type == ARDOUR::Windows_VST) {
1220                         prop = node.property ("id");
1221                 }
1222 #endif
1223
1224 #ifdef LXVST_SUPPORT
1225                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1226
1227                 if (type == ARDOUR::LXVST) {
1228                         prop = node.property ("id");
1229                 }
1230 #endif
1231                 /* recheck  */
1232
1233                 if (prop == 0) {
1234                         error << _("Plugin has no unique ID field") << endmsg;
1235                         return -1;
1236                 }
1237         }
1238
1239         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1240
1241         /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1242          * allow to move sessions windows <> linux */
1243 #ifdef LXVST_SUPPORT
1244         if (plugin == 0 && type == ARDOUR::Windows_VST) {
1245                 type = ARDOUR::LXVST;
1246                 plugin = find_plugin (_session, prop->value(), type);
1247         }
1248 #endif
1249
1250 #ifdef WINDOWS_VST_SUPPORT
1251         if (plugin == 0 && type == ARDOUR::LXVST) {
1252                 type = ARDOUR::Windows_VST;
1253                 plugin = find_plugin (_session, prop->value(), type);
1254         }
1255 #endif
1256
1257         if (plugin == 0) {
1258                 error << string_compose(
1259                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1260                           "Perhaps it was removed or moved since it was last used."),
1261                         prop->value())
1262                       << endmsg;
1263                 return -1;
1264         }
1265
1266         if (type == ARDOUR::Lua) {
1267                 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1268                 // we need to load the script to set the name and parameters.
1269                 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1270                 if (ls && lp) {
1271                         lp->set_script_from_state (*ls);
1272                 }
1273         }
1274
1275         // The name of the PluginInsert comes from the plugin, nothing else
1276         _name = plugin->get_info()->name;
1277
1278         uint32_t count = 1;
1279
1280         // Processor::set_state() will set this, but too late
1281         // for it to be available when setting up plugin
1282         // state. We can't call Processor::set_state() until
1283         // the plugins themselves are created and added.
1284
1285         set_id (node);
1286
1287         if (_plugins.empty()) {
1288                 /* if we are adding the first plugin, we will need to set
1289                    up automatable controls.
1290                 */
1291                 add_plugin (plugin);
1292                 create_automatable_parameters ();
1293                 set_control_ids (node, version);
1294         }
1295
1296         if ((prop = node.property ("count")) != 0) {
1297                 sscanf (prop->value().c_str(), "%u", &count);
1298         }
1299
1300         if (_plugins.size() != count) {
1301                 for (uint32_t n = 1; n < count; ++n) {
1302                         add_plugin (plugin_factory (plugin));
1303                 }
1304         }
1305
1306         Processor::set_state (node, version);
1307
1308         PBD::ID new_id = this->id();
1309         PBD::ID old_id = this->id();
1310
1311         if ((prop = node.property ("id")) != 0) {
1312                 old_id = prop->value ();
1313         }
1314
1315         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1316
1317                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1318                    and set all plugins to the same state.
1319                 */
1320
1321                 if ((*niter)->name() == plugin->state_node_name()) {
1322
1323                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1324                                 /* Plugin state can include external files which are named after the ID.
1325                                  *
1326                                  * If regenerate_xml_or_string_ids() is set, the ID will already have
1327                                  * been changed, so we need to use the old ID from the XML to load the
1328                                  * state and then update the ID.
1329                                  *
1330                                  * When copying a plugin-state, route_ui takes care of of updating the ID,
1331                                  * but we need to call set_insert_id() to clear the cached plugin-state
1332                                  * and force a change.
1333                                  */
1334                                 if (!regenerate_xml_or_string_ids ()) {
1335                                         (*i)->set_insert_id (new_id);
1336                                 } else {
1337                                         (*i)->set_insert_id (old_id);
1338                                 }
1339
1340                                 (*i)->set_state (**niter, version);
1341
1342                                 if (regenerate_xml_or_string_ids ()) {
1343                                         (*i)->set_insert_id (new_id);
1344                                 }
1345                         }
1346
1347                         break;
1348                 }
1349         }
1350
1351         if (version < 3000) {
1352
1353                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1354                    this is all handled by Automatable
1355                 */
1356
1357                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1358                         if ((*niter)->name() == "Redirect") {
1359                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1360                                 Processor::set_state (**niter, version);
1361                                 break;
1362                         }
1363                 }
1364
1365                 set_parameter_state_2X (node, version);
1366         }
1367
1368         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1369                 if (active()) {
1370                         (*i)->activate ();
1371                 } else {
1372                         (*i)->deactivate ();
1373                 }
1374         }
1375
1376         return 0;
1377 }
1378
1379 void
1380 PluginInsert::update_id (PBD::ID id)
1381 {
1382         set_id (id.to_s());
1383         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1384                 (*i)->set_insert_id (id);
1385         }
1386 }
1387
1388 void
1389 PluginInsert::set_state_dir (const std::string& d)
1390 {
1391         // state() only saves the state of the first plugin
1392         _plugins[0]->set_state_dir (d);
1393 }
1394
1395 void
1396 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1397 {
1398         XMLNodeList nlist = node.children();
1399         XMLNodeIterator niter;
1400
1401         /* look for port automation node */
1402
1403         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1404
1405                 if ((*niter)->name() != port_automation_node_name) {
1406                         continue;
1407                 }
1408
1409                 XMLNodeList cnodes;
1410                 XMLProperty *cprop;
1411                 XMLNodeConstIterator iter;
1412                 XMLNode *child;
1413                 const char *port;
1414                 uint32_t port_id;
1415
1416                 cnodes = (*niter)->children ("port");
1417
1418                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1419
1420                         child = *iter;
1421
1422                         if ((cprop = child->property("number")) != 0) {
1423                                 port = cprop->value().c_str();
1424                         } else {
1425                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1426                                 continue;
1427                         }
1428
1429                         sscanf (port, "%" PRIu32, &port_id);
1430
1431                         if (port_id >= _plugins[0]->parameter_count()) {
1432                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1433                                 continue;
1434                         }
1435
1436                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1437                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1438
1439                         if (c && c->alist()) {
1440                                 if (!child->children().empty()) {
1441                                         c->alist()->set_state (*child->children().front(), version);
1442
1443                                         /* In some cases 2.X saves lists with min_yval and max_yval
1444                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
1445                                            in A3 because these min/max values are used to compute
1446                                            where GUI control points should be drawn.  If we see such
1447                                            values, `correct' them to the min/max of the appropriate
1448                                            parameter.
1449                                         */
1450
1451                                         float min_y = c->alist()->get_min_y ();
1452                                         float max_y = c->alist()->get_max_y ();
1453
1454                                         ParameterDescriptor desc;
1455                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
1456
1457                                         if (min_y == FLT_MIN) {
1458                                                 min_y = desc.lower;
1459                                         }
1460
1461                                         if (max_y == FLT_MAX) {
1462                                                 max_y = desc.upper;
1463                                         }
1464
1465                                         c->alist()->set_yrange (min_y, max_y);
1466                                 }
1467                         } else {
1468                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1469                         }
1470                 }
1471
1472                 /* done */
1473
1474                 break;
1475         }
1476 }
1477
1478
1479 string
1480 PluginInsert::describe_parameter (Evoral::Parameter param)
1481 {
1482         if (param.type() == PluginAutomation) {
1483                 return _plugins[0]->describe_parameter (param);
1484         } else if (param.type() == PluginPropertyAutomation) {
1485                 boost::shared_ptr<AutomationControl> c(automation_control(param));
1486                 if (c && !c->desc().label.empty()) {
1487                         return c->desc().label;
1488                 }
1489         }
1490         return Automatable::describe_parameter(param);
1491 }
1492
1493 ARDOUR::framecnt_t
1494 PluginInsert::signal_latency() const
1495 {
1496         if (_user_latency) {
1497                 return _user_latency;
1498         }
1499
1500         return _plugins[0]->signal_latency ();
1501 }
1502
1503 ARDOUR::PluginType
1504 PluginInsert::type ()
1505 {
1506        return plugin()->get_info()->type;
1507 }
1508
1509 PluginInsert::PluginControl::PluginControl (PluginInsert*                     p,
1510                                             const Evoral::Parameter&          param,
1511                                             const ParameterDescriptor&        desc,
1512                                             boost::shared_ptr<AutomationList> list)
1513         : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1514         , _plugin (p)
1515 {
1516         if (alist()) {
1517                 alist()->reset_default (desc.normal);
1518                 if (desc.toggled) {
1519                         list->set_interpolation(Evoral::ControlList::Discrete);
1520                 }
1521         }
1522
1523         if (desc.toggled) {
1524                 set_flags(Controllable::Toggle);
1525         }
1526 }
1527
1528 /** @param val `user' value */
1529 void
1530 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1531 {
1532         if (writable()) {
1533                 _set_value (user_val, group_override);
1534         }
1535 }
1536 void
1537 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1538 {
1539         /* used only by automation playback */
1540         _set_value (user_val, Controllable::NoGroup);
1541 }
1542
1543 void
1544 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1545 {
1546         /* FIXME: probably should be taking out some lock here.. */
1547
1548         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1549                 (*i)->set_parameter (_list->parameter().id(), user_val);
1550         }
1551
1552         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1553         if (iasp) {
1554                 iasp->set_parameter (_list->parameter().id(), user_val);
1555         }
1556
1557         AutomationControl::set_value (user_val, group_override);
1558 }
1559
1560 void
1561 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1562 {
1563         AutomationControl::set_value (user_val, Controllable::NoGroup);
1564 }
1565
1566 XMLNode&
1567 PluginInsert::PluginControl::get_state ()
1568 {
1569         stringstream ss;
1570
1571         XMLNode& node (AutomationControl::get_state());
1572         ss << parameter().id();
1573         node.add_property (X_("parameter"), ss.str());
1574 #ifdef LV2_SUPPORT
1575         boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1576         if (lv2plugin) {
1577                 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1578         }
1579 #endif
1580
1581         return node;
1582 }
1583
1584 /** @return `user' val */
1585 double
1586 PluginInsert::PluginControl::get_value () const
1587 {
1588         boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1589
1590         if (!plugin) {
1591                 return 0.0;
1592         }
1593
1594         return plugin->get_parameter (_list->parameter().id());
1595 }
1596
1597 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert*                     p,
1598                                                             const Evoral::Parameter&          param,
1599                                                             const ParameterDescriptor&        desc,
1600                                                             boost::shared_ptr<AutomationList> list)
1601         : AutomationControl (p->session(), param, desc, list)
1602         , _plugin (p)
1603 {
1604         if (alist()) {
1605                 alist()->set_yrange (desc.lower, desc.upper);
1606                 alist()->reset_default (desc.normal);
1607         }
1608
1609         if (desc.toggled) {
1610                 set_flags(Controllable::Toggle);
1611         }
1612 }
1613
1614 void
1615 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1616 {
1617         if (writable()) {
1618                 set_value_unchecked (user_val);
1619         }
1620 }
1621
1622 void
1623 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1624 {
1625         /* Old numeric set_value(), coerce to appropriate datatype if possible.
1626            This is lossy, but better than nothing until Ardour's automation system
1627            can handle various datatypes all the way down. */
1628         const Variant value(_desc.datatype, user_val);
1629         if (value.type() == Variant::NOTHING) {
1630                 error << "set_value(double) called for non-numeric property" << endmsg;
1631                 return;
1632         }
1633
1634         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1635                 (*i)->set_property(_list->parameter().id(), value);
1636         }
1637
1638         _value = value;
1639         AutomationControl::set_value (user_val, Controllable::NoGroup);
1640 }
1641
1642 XMLNode&
1643 PluginInsert::PluginPropertyControl::get_state ()
1644 {
1645         stringstream ss;
1646
1647         XMLNode& node (AutomationControl::get_state());
1648         ss << parameter().id();
1649         node.add_property (X_("property"), ss.str());
1650         node.remove_property (X_("value"));
1651
1652         return node;
1653 }
1654
1655 double
1656 PluginInsert::PluginPropertyControl::get_value () const
1657 {
1658         return _value.to_double();
1659 }
1660
1661 boost::shared_ptr<Plugin>
1662 PluginInsert::get_impulse_analysis_plugin()
1663 {
1664         boost::shared_ptr<Plugin> ret;
1665         if (_impulseAnalysisPlugin.expired()) {
1666                 ret = plugin_factory(_plugins[0]);
1667                 ret->configure_io (input_streams (), output_streams ());
1668                 _impulseAnalysisPlugin = ret;
1669         } else {
1670                 ret = _impulseAnalysisPlugin.lock();
1671         }
1672
1673         return ret;
1674 }
1675
1676 void
1677 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1678 {
1679         // called from outside the audio thread, so this should be safe
1680         // only do audio as analysis is (currently) only for audio plugins
1681         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, input_streams().n_audio(),  nframes);
1682         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1683
1684         _signal_analysis_collected_nframes   = 0;
1685         _signal_analysis_collect_nframes_max = nframes;
1686 }
1687
1688 /** Add a plugin to our list */
1689 void
1690 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1691 {
1692         plugin->set_insert_id (this->id());
1693
1694         if (_plugins.empty()) {
1695                 /* first (and probably only) plugin instance - connect to relevant signals
1696                  */
1697
1698                 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1699                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1700                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1701         }
1702
1703         _plugins.push_back (plugin);
1704 }
1705
1706 void
1707 PluginInsert::realtime_handle_transport_stopped ()
1708 {
1709         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1710                 (*i)->realtime_handle_transport_stopped ();
1711         }
1712 }
1713
1714 void
1715 PluginInsert::realtime_locate ()
1716 {
1717         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1718                 (*i)->realtime_locate ();
1719         }
1720 }
1721
1722 void
1723 PluginInsert::monitoring_changed ()
1724 {
1725         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1726                 (*i)->monitoring_changed ();
1727         }
1728 }
1729
1730 void
1731 PluginInsert::start_touch (uint32_t param_id)
1732 {
1733         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1734         if (ac) {
1735                 ac->start_touch (session().audible_frame());
1736         }
1737 }
1738
1739 void
1740 PluginInsert::end_touch (uint32_t param_id)
1741 {
1742         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1743         if (ac) {
1744                 ac->stop_touch (true, session().audible_frame());
1745         }
1746 }