libs/ardour/plugin_insert.cc

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