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