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