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/plugin.h"
  37 #include "ardour/plugin_insert.h"
  38
  39 #ifdef LV2_SUPPORT
  40 #include "ardour/lv2_plugin.h"
  41 #endif
  42
  43 #ifdef WINDOWS_VST_SUPPORT
  44 #include "ardour/windows_vst_plugin.h"
  45 #endif
  46
  47 #ifdef LXVST_SUPPORT
  48 #include "ardour/lxvst_plugin.h"
  49 #endif
  50
  51 #ifdef AUDIOUNIT_SUPPORT
  52 #include "ardour/audio_unit.h"
  53 #endif
  54
  55 #include "ardour/session.h"
  56 #include "ardour/types.h"
  57
  58 #include "i18n.h"
  59
  60 using namespace std;
  61 using namespace ARDOUR;
  62 using namespace PBD;
  63
  64 const string PluginInsert::port_automation_node_name = "PortAutomation";
  65
  66 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
  67         : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
  68         , _signal_analysis_collected_nframes(0)
  69         , _signal_analysis_collect_nframes_max(0)
  70 {
  71         /* the first is the master */
  72
  73         if (plug) {
  74                 add_plugin (plug);
  75                 create_automatable_parameters ();
  76         }
  77 }
  78
  79 bool
  80 PluginInsert::set_count (uint32_t num)
  81 {
  82         bool require_state = !_plugins.empty();
  83
  84         /* this is a bad idea.... we shouldn't do this while active.
  85            only a route holding their redirect_lock should be calling this
  86         */
  87
  88         if (num == 0) {
  89                 return false;
  90         } else if (num > _plugins.size()) {
  91                 uint32_t diff = num - _plugins.size();
  92
  93                 for (uint32_t n = 0; n < diff; ++n) {
  94                         boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
  95                         add_plugin (p);
  96                         if (active ()) {
  97                                 p->activate ();
  98                         }
  99
 100                         if (require_state) {
 101                                 /* XXX do something */
 102                         }
 103                 }
 104
 105         } else if (num < _plugins.size()) {
 106                 uint32_t diff = _plugins.size() - num;
 107                 for (uint32_t n= 0; n < diff; ++n) {
 108                         _plugins.pop_back();
 109                 }
 110         }
 111
 112         return true;
 113 }
 114
 115 PluginInsert::~PluginInsert ()
 116 {
 117 }
 118
 119 void
 120 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
 121 {
 122         if (which.type() != PluginAutomation)
 123                 return;
 124
 125         boost::shared_ptr<AutomationControl> c
 126                         = boost::dynamic_pointer_cast<AutomationControl>(control (which));
 127
 128         if (c && s != Off) {
 129                 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
 130         }
 131 }
 132
 133 ChanCount
 134 PluginInsert::output_streams() const
 135 {
 136         assert (!_plugins.empty());
 137
 138         PluginInfoPtr info = _plugins.front()->get_info();
 139
 140         if (info->reconfigurable_io()) {
 141                 ChanCount out = _plugins.front()->output_streams ();
 142                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
 143                 return out;
 144         } else {
 145                 ChanCount out = info->n_outputs;
 146                 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
 147                 out.set_audio (out.n_audio() * _plugins.size());
 148                 out.set_midi (out.n_midi() * _plugins.size() + midi_bypass.n_midi());
 149                 return out;
 150         }
 151 }
 152
 153 ChanCount
 154 PluginInsert::input_streams() const
 155 {
 156         assert (!_plugins.empty());
 157
 158         ChanCount in;
 159
 160         PluginInfoPtr info = _plugins.front()->get_info();
 161
 162         if (info->reconfigurable_io()) {
 163                 assert (_plugins.size() == 1);
 164                 in = _plugins.front()->input_streams();
 165         } else {
 166                 in = info->n_inputs;
 167         }
 168
 169         DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
 170
 171         if (_match.method == Split) {
 172
 173                 /* we are splitting 1 processor input to multiple plugin inputs,
 174                    so we have a maximum of 1 stream of each type.
 175                 */
 176                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 177                         if (in.get (*t) > 1) {
 178                                 in.set (*t, 1);
 179                         }
 180                 }
 181                 return in;
 182
 183         } else if (_match.method == Hide) {
 184
 185                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 186                         in.set (*t, in.get (*t) - _match.hide.get (*t));
 187                 }
 188                 return in;
 189
 190         } else {
 191
 192                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 193                         in.set (*t, in.get (*t) * _plugins.size ());
 194                 }
 195
 196                 return in;
 197         }
 198 }
 199
 200 ChanCount
 201 PluginInsert::natural_output_streams() const
 202 {
 203         return _plugins[0]->get_info()->n_outputs;
 204 }
 205
 206 ChanCount
 207 PluginInsert::natural_input_streams() const
 208 {
 209         return _plugins[0]->get_info()->n_inputs;
 210 }
 211
 212 bool
 213 PluginInsert::has_no_inputs() const
 214 {
 215         return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
 216 }
 217
 218 bool
 219 PluginInsert::has_no_audio_inputs() const
 220 {
 221         return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
 222 }
 223
 224 bool
 225 PluginInsert::is_midi_instrument() const
 226 {
 227         /* XXX more finesse is possible here. VST plugins have a
 228            a specific "instrument" flag, for example.
 229          */
 230         PluginInfoPtr pi = _plugins[0]->get_info();
 231
 232         return pi->n_inputs.n_midi() != 0 &&
 233                 pi->n_outputs.n_audio() > 0;
 234 }
 235
 236 void
 237 PluginInsert::create_automatable_parameters ()
 238 {
 239         assert (!_plugins.empty());
 240
 241         set<Evoral::Parameter> a = _plugins.front()->automatable ();
 242
 243         Plugin::ParameterDescriptor desc;
 244
 245         for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
 246                 if (i->type() == PluginAutomation) {
 247
 248                         Evoral::Parameter param(*i);
 249
 250                         _plugins.front()->get_parameter_descriptor(i->id(), desc);
 251
 252                         /* the Parameter belonging to the actual plugin doesn't have its range set
 253                            but we want the Controllable related to this Parameter to have those limits.
 254                         */
 255
 256                         param.set_range (desc.lower, desc.upper, _plugins.front()->default_value(i->id()), desc.toggled);
 257                         can_automate (param);
 258                         boost::shared_ptr<AutomationList> list(new AutomationList(param));
 259                         add_control (boost::shared_ptr<AutomationControl> (new PluginControl(this, param, list)));
 260                 }
 261         }
 262 }
 263
 264 void
 265 PluginInsert::parameter_changed (uint32_t which, float val)
 266 {
 267         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
 268
 269         if (ac) {
 270                 ac->set_value (val);
 271
 272                 Plugins::iterator i = _plugins.begin();
 273
 274                 /* don't set the first plugin, just all the slaves */
 275
 276                 if (i != _plugins.end()) {
 277                         ++i;
 278                         for (; i != _plugins.end(); ++i) {
 279                                 (*i)->set_parameter (which, val);
 280                         }
 281                 }
 282         }
 283 }
 284
 285 int
 286 PluginInsert::set_block_size (pframes_t nframes)
 287 {
 288         int ret = 0;
 289         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 290                 if ((*i)->set_block_size (nframes) != 0) {
 291                         ret = -1;
 292                 }
 293         }
 294         return ret;
 295 }
 296
 297 void
 298 PluginInsert::activate ()
 299 {
 300         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 301                 (*i)->activate ();
 302         }
 303
 304         Processor::activate ();
 305 }
 306
 307 void
 308 PluginInsert::deactivate ()
 309 {
 310         Processor::deactivate ();
 311
 312         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 313                 (*i)->deactivate ();
 314         }
 315 }
 316
 317 void
 318 PluginInsert::flush ()
 319 {
 320         for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 321                 (*i)->flush ();
 322         }
 323 }
 324
 325 void
 326 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
 327 {
 328         // Calculate if, and how many frames we need to collect for analysis
 329         framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
 330                                              _signal_analysis_collected_nframes);
 331         if (nframes < collect_signal_nframes) { // we might not get all frames now
 332                 collect_signal_nframes = nframes;
 333         }
 334
 335         ChanCount const in_streams = input_streams ();
 336         ChanCount const out_streams = output_streams ();
 337
 338         ChanMapping in_map (in_streams);
 339         ChanMapping out_map (out_streams);
 340         bool valid;
 341         if (_match.method == Split) {
 342                 /* fix the input mapping so that we have maps for each of the plugin's inputs */
 343                 in_map = ChanMapping (natural_input_streams ());
 344
 345                 /* copy the first stream's buffer contents to the others */
 346                 /* XXX: audio only */
 347                 uint32_t first_idx = in_map.get (DataType::AUDIO, 0, &valid);
 348                 if (valid) {
 349                         Sample const * mono = bufs.get_audio (first_idx).data (offset);
 350                         for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
 351                                 memcpy (bufs.get_audio (in_map.get (DataType::AUDIO, i, &valid)).data (offset), mono, sizeof (Sample) * nframes);
 352                         }
 353                 }
 354         }
 355
 356         /* Note that we've already required that plugins
 357            be able to handle in-place processing.
 358         */
 359
 360         if (with_auto) {
 361
 362                 uint32_t n = 0;
 363
 364                 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
 365
 366                         boost::shared_ptr<AutomationControl> c
 367                                 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
 368
 369                         if (c->parameter().type() == PluginAutomation && c->automation_playback()) {
 370                                 bool valid;
 371
 372                                 const float val = c->list()->rt_safe_eval (now, valid);
 373
 374                                 if (valid) {
 375                                         c->set_value(val);
 376                                 }
 377
 378                         }
 379                 }
 380         }
 381
 382         if (collect_signal_nframes > 0) {
 383                 // collect input
 384                 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 385                 //std::cerr << "               streams " << input_streams().n_audio() << std::endl;
 386                 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
 387
 388                 _signal_analysis_inputs.set_count(input_streams());
 389
 390                 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
 391                         _signal_analysis_inputs.get_audio(i).read_from(
 392                                 bufs.get_audio(i),
 393                                 collect_signal_nframes,
 394                                 _signal_analysis_collected_nframes); // offset is for target buffer
 395                 }
 396
 397         }
 398
 399         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 400                 (*i)->connect_and_run(bufs, in_map, out_map, nframes, offset);
 401                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 402                         in_map.offset_to(*t, natural_input_streams().get(*t));
 403                         out_map.offset_to(*t, natural_output_streams().get(*t));
 404                 }
 405         }
 406
 407         if (collect_signal_nframes > 0) {
 408                 // collect output
 409                 //std::cerr << "       output, bufs " << bufs.count().n_audio() << " count,  " << bufs.available().n_audio() << " available" << std::endl;
 410                 //std::cerr << "               streams " << output_streams().n_audio() << std::endl;
 411
 412                 _signal_analysis_outputs.set_count(output_streams());
 413
 414                 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
 415                         _signal_analysis_outputs.get_audio(i).read_from(
 416                                 bufs.get_audio(i),
 417                                 collect_signal_nframes,
 418                                 _signal_analysis_collected_nframes); // offset is for target buffer
 419                 }
 420
 421                 _signal_analysis_collected_nframes += collect_signal_nframes;
 422                 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
 423
 424                 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
 425                         _signal_analysis_collect_nframes_max = 0;
 426                         _signal_analysis_collected_nframes   = 0;
 427
 428                         AnalysisDataGathered(&_signal_analysis_inputs,
 429                                              &_signal_analysis_outputs);
 430                 }
 431         }
 432         /* leave remaining channel buffers alone */
 433 }
 434
 435 void
 436 PluginInsert::silence (framecnt_t nframes)
 437 {
 438         if (!active ()) {
 439                 return;
 440         }
 441
 442         ChanMapping in_map(input_streams());
 443         ChanMapping out_map(output_streams());
 444
 445         if (_match.method == Split) {
 446                 /* fix the input mapping so that we have maps for each of the plugin's inputs */
 447                 in_map = ChanMapping (natural_input_streams ());
 448         }
 449
 450         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 451                 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
 452         }
 453 }
 454
 455 void
 456 PluginInsert::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_frame*/, pframes_t nframes, bool)
 457 {
 458         if (_pending_active) {
 459                 /* run as normal if we are active or moving from inactive to active */
 460
 461                 if (_session.transport_rolling()) {
 462                         automation_run (bufs, nframes);
 463                 } else {
 464                         connect_and_run (bufs, nframes, 0, false);
 465                 }
 466
 467         } else {
 468                 if (has_no_audio_inputs()) {
 469
 470                         /* silence all (audio) outputs. Should really declick
 471                          * at the transitions of "active"
 472                          */
 473
 474                         uint32_t out = output_streams().n_audio ();
 475
 476                         for (uint32_t n = 0; n < out; ++n) {
 477                                 bufs.get_audio (n).silence (nframes);
 478                         }
 479
 480                         bufs.count().set_audio (out);
 481
 482                 } else {
 483
 484                         /* does this need to be done with MIDI? it appears not */
 485
 486                         uint32_t in = input_streams ().n_audio ();
 487                         uint32_t out = output_streams().n_audio ();
 488
 489                         if (out > in) {
 490
 491                                 /* not active, but something has make up for any channel count increase */
 492
 493                                 for (uint32_t n = out - in; n < out; ++n) {
 494                                         memcpy (bufs.get_audio (n).data(), bufs.get_audio(in - 1).data(), sizeof (Sample) * nframes);
 495                                 }
 496                         }
 497
 498                         bufs.count().set_audio (out);
 499                 }
 500         }
 501
 502         _active = _pending_active;
 503
 504         /* we have no idea whether the plugin generated silence or not, so mark
 505          * all buffers appropriately.
 506          */
 507
 508 }
 509
 510 void
 511 PluginInsert::set_parameter (Evoral::Parameter param, float val)
 512 {
 513         if (param.type() != PluginAutomation) {
 514                 return;
 515         }
 516
 517         /* the others will be set from the event triggered by this */
 518
 519         _plugins[0]->set_parameter (param.id(), val);
 520
 521         boost::shared_ptr<AutomationControl> ac
 522                         = boost::dynamic_pointer_cast<AutomationControl>(control(param));
 523
 524         if (ac) {
 525                 ac->set_value(val);
 526         } else {
 527                 warning << "set_parameter called for nonexistant parameter "
 528                         << EventTypeMap::instance().to_symbol(param) << endmsg;
 529         }
 530
 531         _session.set_dirty();
 532 }
 533
 534 float
 535 PluginInsert::get_parameter (Evoral::Parameter param)
 536 {
 537         if (param.type() != PluginAutomation) {
 538                 return 0.0;
 539         } else {
 540                 assert (!_plugins.empty ());
 541                 return _plugins[0]->get_parameter (param.id());
 542         }
 543 }
 544
 545 void
 546 PluginInsert::automation_run (BufferSet& bufs, pframes_t nframes)
 547 {
 548         Evoral::ControlEvent next_event (0, 0.0f);
 549         framepos_t now = _session.transport_frame ();
 550         framepos_t end = now + nframes;
 551         framecnt_t offset = 0;
 552
 553         Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
 554
 555         if (!lm.locked()) {
 556                 connect_and_run (bufs, nframes, offset, false);
 557                 return;
 558         }
 559
 560         if (!find_next_event (now, end, next_event) || requires_fixed_sized_buffers()) {
 561
 562                 /* no events have a time within the relevant range */
 563
 564                 connect_and_run (bufs, nframes, offset, true, now);
 565                 return;
 566         }
 567
 568         while (nframes) {
 569
 570                 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
 571
 572                 connect_and_run (bufs, cnt, offset, true, now);
 573
 574                 nframes -= cnt;
 575                 offset += cnt;
 576                 now += cnt;
 577
 578                 if (!find_next_event (now, end, next_event)) {
 579                         break;
 580                 }
 581         }
 582
 583         /* cleanup anything that is left to do */
 584
 585         if (nframes) {
 586                 connect_and_run (bufs, nframes, offset, true, now);
 587         }
 588 }
 589
 590 float
 591 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
 592 {
 593         if (param.type() != PluginAutomation)
 594                 return 1.0;
 595
 596         if (_plugins.empty()) {
 597                 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
 598                       << endmsg;
 599                 /*NOTREACHED*/
 600         }
 601
 602         return _plugins[0]->default_value (param.id());
 603 }
 604
 605 boost::shared_ptr<Plugin>
 606 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
 607 {
 608         boost::shared_ptr<LadspaPlugin> lp;
 609 #ifdef LV2_SUPPORT
 610         boost::shared_ptr<LV2Plugin> lv2p;
 611 #endif
 612 #ifdef WINDOWS_VST_SUPPORT
 613         boost::shared_ptr<WindowsVSTPlugin> vp;
 614 #endif
 615 #ifdef LXVST_SUPPORT
 616         boost::shared_ptr<LXVSTPlugin> lxvp;
 617 #endif
 618 #ifdef AUDIOUNIT_SUPPORT
 619         boost::shared_ptr<AUPlugin> ap;
 620 #endif
 621
 622         if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
 623                 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
 624 #ifdef LV2_SUPPORT
 625         } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
 626                 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
 627 #endif
 628 #ifdef WINDOWS_VST_SUPPORT
 629         } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
 630                 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
 631 #endif
 632 #ifdef LXVST_SUPPORT
 633         } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
 634                 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
 635 #endif
 636 #ifdef AUDIOUNIT_SUPPORT
 637         } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
 638                 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
 639 #endif
 640         }
 641
 642         fatal << string_compose (_("programming error: %1"),
 643                           X_("unknown plugin type in PluginInsert::plugin_factory"))
 644               << endmsg;
 645         /*NOTREACHED*/
 646         return boost::shared_ptr<Plugin> ((Plugin*) 0);
 647 }
 648
 649 bool
 650 PluginInsert::configure_io (ChanCount in, ChanCount out)
 651 {
 652         Match old_match = _match;
 653
 654         /* set the matching method and number of plugins that we will use to meet this configuration */
 655         _match = private_can_support_io_configuration (in, out);
 656         if (set_count (_match.plugins) == false) {
 657                 return false;
 658         }
 659
 660         /* a signal needs emitting if we start or stop splitting */
 661         if (old_match.method != _match.method && (old_match.method == Split || _match.method == Split)) {
 662                 SplittingChanged (); /* EMIT SIGNAL */
 663         }
 664
 665         /* configure plugins */
 666         switch (_match.method) {
 667         case Split:
 668         case Hide:
 669                 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out)) {
 670                         return false;
 671                 }
 672                 break;
 673
 674         default:
 675                 if (_plugins.front()->configure_io (in, out) == false) {
 676                         return false;
 677                 }
 678                 break;
 679         }
 680
 681         // we don't know the analysis window size, so we must work with the
 682         // current buffer size here. each request for data fills in these
 683         // buffers and the analyser makes sure it gets enough data for the
 684         // analysis window
 685         session().ensure_buffer_set (_signal_analysis_inputs, in);
 686         //_signal_analysis_inputs.set_count (in);
 687
 688         session().ensure_buffer_set (_signal_analysis_outputs, out);
 689         //_signal_analysis_outputs.set_count (out);
 690
 691         // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
 692
 693         return Processor::configure_io (in, out);
 694 }
 695
 696 /** Decide whether this PluginInsert can support a given IO configuration.
 697  *  To do this, we run through a set of possible solutions in rough order of
 698  *  preference.
 699  *
 700  *  @param in Required input channel count.
 701  *  @param out Filled in with the output channel count if we return true.
 702  *  @return true if the given IO configuration can be supported.
 703  */
 704 bool
 705 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 706 {
 707         return private_can_support_io_configuration (in, out).method != Impossible;
 708 }
 709
 710 /** A private version of can_support_io_configuration which returns the method
 711  *  by which the configuration can be matched, rather than just whether or not
 712  *  it can be.
 713  */
 714 PluginInsert::Match
 715 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
 716 {
 717         PluginInfoPtr info = _plugins.front()->get_info();
 718         ChanCount in; in += inx;
 719         midi_bypass.reset();
 720
 721         if (info->reconfigurable_io()) {
 722                 /* Plugin has flexible I/O, so delegate to it */
 723                 bool const r = _plugins.front()->can_support_io_configuration (in, out);
 724                 if (!r) {
 725                         return Match (Impossible, 0);
 726                 }
 727
 728                 return Match (Delegate, 1);
 729         }
 730
 731         ChanCount inputs  = info->n_inputs;
 732         ChanCount outputs = info->n_outputs;
 733
 734         if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
 735                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
 736                 midi_bypass.set(DataType::MIDI, 1);
 737         }
 738         if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
 739                 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
 740                 in.set(DataType::MIDI, 0);
 741         }
 742
 743         bool no_inputs = true;
 744         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 745                 if (inputs.get (*t) != 0) {
 746                         no_inputs = false;
 747                         break;
 748                 }
 749         }
 750
 751         if (no_inputs) {
 752                 /* no inputs so we can take any input configuration since we throw it away */
 753                 out = outputs + midi_bypass;
 754                 return Match (NoInputs, 1);
 755         }
 756
 757         /* Plugin inputs match requested inputs exactly */
 758         if (inputs == in) {
 759                 out = outputs + midi_bypass;
 760                 return Match (ExactMatch, 1);
 761         }
 762
 763         /* We may be able to run more than one copy of the plugin within this insert
 764            to cope with the insert having more inputs than the plugin.
 765            We allow replication only for plugins with either zero or 1 inputs and outputs
 766            for every valid data type.
 767         */
 768
 769         uint32_t f             = 0;
 770         bool     can_replicate = true;
 771         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 772
 773                 uint32_t nin = inputs.get (*t);
 774
 775                 // No inputs of this type
 776                 if (nin == 0 && in.get(*t) == 0) {
 777                         continue;
 778                 }
 779
 780                 if (nin != 1 || outputs.get (*t) != 1) {
 781                         can_replicate = false;
 782                         break;
 783                 }
 784
 785                 // Potential factor not set yet
 786                 if (f == 0) {
 787                         f = in.get(*t) / nin;
 788                 }
 789
 790                 // Factor for this type does not match another type, can not replicate
 791                 if (f != (in.get(*t) / nin)) {
 792                         can_replicate = false;
 793                         break;
 794                 }
 795         }
 796
 797         if (can_replicate) {
 798                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 799                         out.set (*t, outputs.get(*t) * f);
 800                 }
 801                 out += midi_bypass;
 802                 return Match (Replicate, f);
 803         }
 804
 805         /* If the processor has exactly one input of a given type, and
 806            the plugin has more, we can feed the single processor input
 807            to some or all of the plugin inputs.  This is rather
 808            special-case-y, but the 1-to-many case is by far the
 809            simplest.  How do I split thy 2 processor inputs to 3
 810            plugin inputs?  Let me count the ways ...
 811         */
 812
 813         bool can_split = true;
 814         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 815
 816                 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
 817                 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
 818
 819                 if (!can_split_type && !nothing_to_do_for_type) {
 820                         can_split = false;
 821                 }
 822         }
 823
 824         if (can_split) {
 825                 out = outputs + midi_bypass;
 826                 return Match (Split, 1);
 827         }
 828
 829         /* If the plugin has more inputs than we want, we can `hide' some of them
 830            by feeding them silence.
 831         */
 832
 833         bool could_hide = false;
 834         bool cannot_hide = false;
 835         ChanCount hide_channels;
 836
 837         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 838                 if (inputs.get(*t) > in.get(*t)) {
 839                         /* there is potential to hide, since the plugin has more inputs of type t than the insert */
 840                         hide_channels.set (*t, inputs.get(*t) - in.get(*t));
 841                         could_hide = true;
 842                 } else if (inputs.get(*t) < in.get(*t)) {
 843                         /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
 844                         cannot_hide = true;
 845                 }
 846         }
 847
 848         if (could_hide && !cannot_hide) {
 849                 out = outputs + midi_bypass;
 850                 return Match (Hide, 1, hide_channels);
 851         }
 852
 853         midi_bypass.reset();
 854         return Match (Impossible, 0);
 855 }
 856
 857 XMLNode&
 858 PluginInsert::get_state ()
 859 {
 860         return state (true);
 861 }
 862
 863 XMLNode&
 864 PluginInsert::state (bool full)
 865 {
 866         XMLNode& node = Processor::state (full);
 867
 868         node.add_property("type", _plugins[0]->state_node_name());
 869         node.add_property("unique-id", _plugins[0]->unique_id());
 870         node.add_property("count", string_compose("%1", _plugins.size()));
 871         node.add_child_nocopy (_plugins[0]->get_state());
 872
 873         for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
 874                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
 875                 if (ac) {
 876                         node.add_child_nocopy (ac->get_state());
 877                 }
 878         }
 879
 880         return node;
 881 }
 882
 883 void
 884 PluginInsert::set_control_ids (const XMLNode& node, int version)
 885 {
 886         const XMLNodeList& nlist = node.children();
 887         XMLNodeConstIterator iter;
 888         set<Evoral::Parameter>::const_iterator p;
 889
 890         for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
 891                 if ((*iter)->name() == Controllable::xml_node_name) {
 892                         const XMLProperty* prop;
 893
 894                         if ((prop = (*iter)->property (X_("parameter"))) != 0) {
 895                                 uint32_t p = atoi (prop->value());
 896
 897                                 /* this may create the new controllable */
 898
 899                                 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
 900
 901 #ifndef NO_PLUGIN_STATE
 902                                 if (!c) {
 903                                         continue;
 904                                 }
 905                                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
 906                                 if (ac) {
 907                                         ac->set_state (**iter, version);
 908                                 }
 909 #endif
 910                         }
 911                 }
 912         }
 913 }
 914
 915 int
 916 PluginInsert::set_state(const XMLNode& node, int version)
 917 {
 918         XMLNodeList nlist = node.children();
 919         XMLNodeIterator niter;
 920         XMLPropertyList plist;
 921         const XMLProperty *prop;
 922         ARDOUR::PluginType type;
 923
 924         if ((prop = node.property ("type")) == 0) {
 925                 error << _("XML node describing plugin is missing the `type' field") << endmsg;
 926                 return -1;
 927         }
 928
 929         if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
 930                 type = ARDOUR::LADSPA;
 931         } else if (prop->value() == X_("lv2")) {
 932                 type = ARDOUR::LV2;
 933         } else if (prop->value() == X_("windows-vst")) {
 934                 type = ARDOUR::Windows_VST;
 935         } else if (prop->value() == X_("lxvst")) {
 936                 type = ARDOUR::LXVST;
 937         } else if (prop->value() == X_("audiounit")) {
 938                 type = ARDOUR::AudioUnit;
 939         } else {
 940                 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
 941                                   prop->value())
 942                       << endmsg;
 943                 return -1;
 944         }
 945
 946         prop = node.property ("unique-id");
 947
 948         if (prop == 0) {
 949 #ifdef WINDOWS_VST_SUPPORT
 950                 /* older sessions contain VST plugins with only an "id" field.
 951                  */
 952
 953                 if (type == ARDOUR::Windows_VST) {
 954                         prop = node.property ("id");
 955                 }
 956 #endif
 957
 958 #ifdef LXVST_SUPPORT
 959                 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
 960
 961                 if (type == ARDOUR::LXVST) {
 962                         prop = node.property ("id");
 963                 }
 964 #endif
 965                 /* recheck  */
 966
 967                 if (prop == 0) {
 968                         error << _("Plugin has no unique ID field") << endmsg;
 969                         return -1;
 970                 }
 971         }
 972
 973         boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
 974
 975         if (plugin == 0) {
 976                 error << string_compose(
 977                         _("Found a reference to a plugin (\"%1\") that is unknown.\n"
 978                           "Perhaps it was removed or moved since it was last used."),
 979                         prop->value())
 980                       << endmsg;
 981                 return -1;
 982         }
 983
 984         // The name of the PluginInsert comes from the plugin, nothing else
 985         _name = plugin->get_info()->name;
 986
 987         uint32_t count = 1;
 988
 989         // Processor::set_state() will set this, but too late
 990         // for it to be available when setting up plugin
 991         // state. We can't call Processor::set_state() until
 992         // the plugins themselves are created and added.
 993
 994         set_id (node);
 995
 996         if (_plugins.empty()) {
 997                 /* if we are adding the first plugin, we will need to set
 998                    up automatable controls.
 999                 */
1000                 add_plugin (plugin);
1001                 create_automatable_parameters ();
1002                 set_control_ids (node, version);
1003         }
1004
1005         if ((prop = node.property ("count")) != 0) {
1006                 sscanf (prop->value().c_str(), "%u", &count);
1007         }
1008
1009         if (_plugins.size() != count) {
1010                 for (uint32_t n = 1; n < count; ++n) {
1011                         add_plugin (plugin_factory (plugin));
1012                 }
1013         }
1014
1015         Processor::set_state (node, version);
1016
1017         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1018
1019                 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1020                    and set all plugins to the same state.
1021                 */
1022
1023                 if ((*niter)->name() == plugin->state_node_name()) {
1024
1025                         plugin->set_state (**niter, version);
1026
1027                         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1028                                 (*i)->set_state (**niter, version);
1029                         }
1030
1031                         break;
1032                 }
1033         }
1034
1035         if (version < 3000) {
1036
1037                 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1038                    this is all handled by Automatable
1039                 */
1040
1041                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1042                         if ((*niter)->name() == "Redirect") {
1043                                 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1044                                 Processor::set_state (**niter, version);
1045                                 break;
1046                         }
1047                 }
1048
1049                 set_parameter_state_2X (node, version);
1050         }
1051
1052         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1053                 if (active()) {
1054                         (*i)->activate ();
1055                 } else {
1056                         (*i)->deactivate ();
1057                 }
1058         }
1059
1060         return 0;
1061 }
1062
1063 void
1064 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1065 {
1066         XMLNodeList nlist = node.children();
1067         XMLNodeIterator niter;
1068
1069         /* look for port automation node */
1070
1071         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1072
1073                 if ((*niter)->name() != port_automation_node_name) {
1074                         continue;
1075                 }
1076
1077                 XMLNodeList cnodes;
1078                 XMLProperty *cprop;
1079                 XMLNodeConstIterator iter;
1080                 XMLNode *child;
1081                 const char *port;
1082                 uint32_t port_id;
1083
1084                 cnodes = (*niter)->children ("port");
1085
1086                 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1087
1088                         child = *iter;
1089
1090                         if ((cprop = child->property("number")) != 0) {
1091                                 port = cprop->value().c_str();
1092                         } else {
1093                                 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1094                                 continue;
1095                         }
1096
1097                         sscanf (port, "%" PRIu32, &port_id);
1098
1099                         if (port_id >= _plugins[0]->parameter_count()) {
1100                                 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1101                                 continue;
1102                         }
1103
1104                         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1105                                         control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1106
1107                         if (c) {
1108                                 if (!child->children().empty()) {
1109                                         c->alist()->set_state (*child->children().front(), version);
1110
1111                                         /* In some cases 2.X saves lists with min_yval and max_yval
1112                                            being FLT_MIN and FLT_MAX respectively.  This causes problems
1113                                            in A3 because these min/max values are used to compute
1114                                            where GUI control points should be drawn.  If we see such
1115                                            values, `correct' them to the min/max of the appropriate
1116                                            parameter.
1117                                         */
1118
1119                                         float min_y = c->alist()->get_min_y ();
1120                                         float max_y = c->alist()->get_max_y ();
1121
1122                                         Plugin::ParameterDescriptor desc;
1123                                         _plugins.front()->get_parameter_descriptor (port_id, desc);
1124
1125                                         if (min_y == FLT_MIN) {
1126                                                 min_y = desc.lower;
1127                                         }
1128
1129                                         if (max_y == FLT_MAX) {
1130                                                 max_y = desc.upper;
1131                                         }
1132
1133                                         c->alist()->set_yrange (min_y, max_y);
1134                                 }
1135                         } else {
1136                                 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1137                         }
1138                 }
1139
1140                 /* done */
1141
1142                 break;
1143         }
1144 }
1145
1146
1147 string
1148 PluginInsert::describe_parameter (Evoral::Parameter param)
1149 {
1150         if (param.type() != PluginAutomation) {
1151                 return Automatable::describe_parameter(param);
1152         }
1153
1154         return _plugins[0]->describe_parameter (param);
1155 }
1156
1157 ARDOUR::framecnt_t
1158 PluginInsert::signal_latency() const
1159 {
1160         if (_user_latency) {
1161                 return _user_latency;
1162         }
1163
1164         return _plugins[0]->signal_latency ();
1165 }
1166
1167 ARDOUR::PluginType
1168 PluginInsert::type ()
1169 {
1170        return plugin()->get_info()->type;
1171 }
1172
1173 PluginInsert::PluginControl::PluginControl (PluginInsert* p, const Evoral::Parameter &param, boost::shared_ptr<AutomationList> list)
1174         : AutomationControl (p->session(), param, list, p->describe_parameter(param))
1175         , _plugin (p)
1176 {
1177         Plugin::ParameterDescriptor desc;
1178         boost::shared_ptr<Plugin> plugin = p->plugin (0);
1179
1180         alist()->reset_default (plugin->default_value (param.id()));
1181
1182         plugin->get_parameter_descriptor (param.id(), desc);
1183         _logarithmic = desc.logarithmic;
1184         _sr_dependent = desc.sr_dependent;
1185         _toggled = desc.toggled;
1186 }
1187
1188 /** @param val `user' value */
1189 void
1190 PluginInsert::PluginControl::set_value (double user_val)
1191 {
1192         /* FIXME: probably should be taking out some lock here.. */
1193
1194         for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1195                 (*i)->set_parameter (_list->parameter().id(), user_val);
1196         }
1197
1198         boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1199         if (iasp) {
1200                 iasp->set_parameter (_list->parameter().id(), user_val);
1201         }
1202
1203         AutomationControl::set_value (user_val);
1204 }
1205
1206 double
1207 PluginInsert::PluginControl::internal_to_interface (double val) const
1208 {
1209         if (_logarithmic) {
1210                 if (val > 0) {
1211                         val = log (val);
1212                 } else {
1213                         val = 0;
1214                 }
1215         }
1216
1217         return val;
1218 }
1219
1220 double
1221 PluginInsert::PluginControl::interface_to_internal (double val) const
1222 {
1223         if (_logarithmic) {
1224                 val = exp (val);
1225         }
1226
1227         return val;
1228 }
1229
1230 XMLNode&
1231 PluginInsert::PluginControl::get_state ()
1232 {
1233         stringstream ss;
1234
1235         XMLNode& node (AutomationControl::get_state());
1236         ss << parameter().id();
1237         node.add_property (X_("parameter"), ss.str());
1238
1239         return node;
1240 }
1241
1242 /** @return `user' val */
1243 double
1244 PluginInsert::PluginControl::get_value () const
1245 {
1246         /* FIXME: probably should be taking out some lock here.. */
1247         return _plugin->get_parameter (_list->parameter());
1248 }
1249
1250 boost::shared_ptr<Plugin>
1251 PluginInsert::get_impulse_analysis_plugin()
1252 {
1253         boost::shared_ptr<Plugin> ret;
1254         if (_impulseAnalysisPlugin.expired()) {
1255                 ret = plugin_factory(_plugins[0]);
1256                 _impulseAnalysisPlugin = ret;
1257         } else {
1258                 ret = _impulseAnalysisPlugin.lock();
1259         }
1260
1261         return ret;
1262 }
1263
1264 void
1265 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1266 {
1267         // called from outside the audio thread, so this should be safe
1268         // only do audio as analysis is (currently) only for audio plugins
1269         _signal_analysis_inputs.ensure_buffers(  DataType::AUDIO, input_streams().n_audio(),  nframes);
1270         _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1271
1272         _signal_analysis_collected_nframes   = 0;
1273         _signal_analysis_collect_nframes_max = nframes;
1274 }
1275
1276 /** Add a plugin to our list */
1277 void
1278 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1279 {
1280         plugin->set_insert_info (this);
1281
1282         if (_plugins.empty()) {
1283                 /* first (and probably only) plugin instance - connect to relevant signals
1284                  */
1285
1286                 plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
1287                 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1288                 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1289         }
1290
1291         _plugins.push_back (plugin);
1292 }
1293
1294 void
1295 PluginInsert::realtime_handle_transport_stopped ()
1296 {
1297         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1298                 (*i)->realtime_handle_transport_stopped ();
1299         }
1300 }
1301
1302 void
1303 PluginInsert::realtime_locate ()
1304 {
1305         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1306                 (*i)->realtime_locate ();
1307         }
1308 }
1309
1310 void
1311 PluginInsert::monitoring_changed ()
1312 {
1313         for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1314                 (*i)->monitoring_changed ();
1315         }
1316 }
1317
1318 void
1319 PluginInsert::start_touch (uint32_t param_id)
1320 {
1321         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1322         if (ac) {
1323                 ac->start_touch (session().audible_frame());
1324         }
1325 }
1326
1327 void
1328 PluginInsert::end_touch (uint32_t param_id)
1329 {
1330         boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1331         if (ac) {
1332                 ac->stop_touch (true, session().audible_frame());
1333         }
1334 }