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