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