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