X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplugin_insert.cc;h=21bc6b5d3d3d2b67cfb058bc7abfb31896add240;hb=4250940ad83200e065b966d0646c75a48bb0f73d;hp=a91ca6e9c0bcedf6d93de9f011a2f5fd5c50de47;hpb=49d044bf04886ad62e08839518c914ccff52794a;p=ardour.git diff --git a/libs/ardour/plugin_insert.cc b/libs/ardour/plugin_insert.cc index a91ca6e9c0..21bc6b5d3d 100644 --- a/libs/ardour/plugin_insert.cc +++ b/libs/ardour/plugin_insert.cc @@ -25,7 +25,7 @@ #include "pbd/failed_constructor.h" #include "pbd/xml++.h" -#include "pbd/convert.h" +#include "pbd/types_convert.h" #include "ardour/audio_buffer.h" #include "ardour/automation_list.h" @@ -50,6 +50,10 @@ #include "ardour/lxvst_plugin.h" #endif +#ifdef MACVST_SUPPORT +#include "ardour/mac_vst_plugin.h" +#endif + #ifdef AUDIOUNIT_SUPPORT #include "ardour/audio_unit.h" #endif @@ -57,7 +61,7 @@ #include "ardour/session.h" #include "ardour/types.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; @@ -67,6 +71,9 @@ const string PluginInsert::port_automation_node_name = "PortAutomation"; PluginInsert::PluginInsert (Session& s, boost::shared_ptr plug) : Processor (s, (plug ? plug->name() : string ("toBeRenamed"))) + , _sc_playback_latency (0) + , _sc_capture_latency (0) + , _plugin_signal_latency (0) , _signal_analysis_collected_nframes(0) , _signal_analysis_collect_nframes_max(0) , _configured (false) @@ -74,6 +81,8 @@ PluginInsert::PluginInsert (Session& s, boost::shared_ptr plug) , _strict_io (false) , _custom_cfg (false) , _maps_from_state (false) + , _latency_changed (false) + , _bypass_port (UINT32_MAX) { /* the first is the master */ @@ -81,14 +90,17 @@ PluginInsert::PluginInsert (Session& s, boost::shared_ptr plug) add_plugin (plug); create_automatable_parameters (); const ChanCount& sc (sidechain_input_pins ()); - if (sc.n_audio () > 0) { - add_sidechain (sc.n_audio ()); + if (sc.n_audio () > 0 || sc.n_midi () > 0) { + add_sidechain (sc.n_audio (), sc.n_midi ()); } } } PluginInsert::~PluginInsert () { + for (CtrlOutMap::const_iterator i = _control_outputs.begin(); i != _control_outputs.end(); ++i) { + boost::dynamic_pointer_cast(i->second)->drop_references (); + } } void @@ -106,9 +118,14 @@ PluginInsert::set_count (uint32_t num) { bool require_state = !_plugins.empty(); + if (require_state && num > 1 && plugin (0)->get_info ()->type == ARDOUR::AudioUnit) { + // we don't allow to replicate AUs + return false; + } + /* this is a bad idea.... we shouldn't do this while active. - only a route holding their redirect_lock should be calling this - */ + * only a route holding their redirect_lock should be calling this + */ if (num == 0) { return false; @@ -142,6 +159,13 @@ PluginInsert::set_count (uint32_t num) } +void +PluginInsert::set_sinks (const ChanCount& c) +{ + _custom_sinks = c; + /* no signal, change will only be visible after re-config */ +} + void PluginInsert::set_outputs (const ChanCount& c) { @@ -174,14 +198,14 @@ PluginInsert::set_preset_out (const ChanCount& c) } bool -PluginInsert::add_sidechain (uint32_t n_audio) +PluginInsert::add_sidechain (uint32_t n_audio, uint32_t n_midi) { // caller must hold process lock if (_sidechain) { return false; } std::ostringstream n; - if (n_audio > 0) { + if (n_audio > 0 || n_midi > 0) { n << "Sidechain " << Session::next_name_id (); } else { n << "TO BE RESET FROM XML"; @@ -190,7 +214,10 @@ PluginInsert::add_sidechain (uint32_t n_audio) _sidechain = boost::shared_ptr (sc); _sidechain->activate (); for (uint32_t n = 0; n < n_audio; ++n) { - _sidechain->input()->add_port ("", owner()); // add a port, don't connect. + _sidechain->input()->add_port ("", owner(), DataType::AUDIO); // add a port, don't connect. + } + for (uint32_t n = 0; n < n_midi; ++n) { + _sidechain->input()->add_port ("", owner(), DataType::MIDI); // add a port, don't connect. } PluginConfigChanged (); /* EMIT SIGNAL */ return true; @@ -203,10 +230,30 @@ PluginInsert::del_sidechain () return false; } _sidechain.reset (); + _sc_playback_latency = 0; + _sc_capture_latency = 0; PluginConfigChanged (); /* EMIT SIGNAL */ return true; } +void +PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback) +{ + if (_sidechain && + (_sc_playback_latency != playback || _sc_capture_latency != capture)) { + _sc_capture_latency = capture; + _sc_playback_latency = playback; + LatencyRange pl; pl.min = pl.max = playback; + LatencyRange cl; cl.min = cl.max = capture; + DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback)); + PortSet& ps (_sidechain->input ()->ports ()); + for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) { + p->set_private_latency_range (pl, true); + p->set_private_latency_range (cl, false); + } + } +} + void PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s) { @@ -217,7 +264,7 @@ PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, Au = boost::dynamic_pointer_cast(control (which)); if (c && s != Off) { - _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame())); + _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_sample())); } } @@ -348,19 +395,55 @@ PluginInsert::has_no_audio_inputs() const return _plugins[0]->get_info()->n_inputs.n_audio() == 0; } -framecnt_t +samplecnt_t PluginInsert::plugin_latency () const { return _plugins.front()->signal_latency (); } bool -PluginInsert::needs_midi_input() const +PluginInsert::is_instrument() const { PluginInfoPtr pip = _plugins[0]->get_info(); - if (pip->needs_midi_input ()) { + if (pip->is_instrument ()) { return true; } - return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0; + return pip->n_inputs.n_midi () != 0 && pip->n_outputs.n_audio () > 0 && pip->n_inputs.n_audio () == 0; +} + +bool +PluginInsert::has_output_presets (ChanCount in, ChanCount out) +{ + if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) { + // collect possible configurations, prefer given in/out + _plugins[0]->can_support_io_configuration (in, out); + } + + PluginOutputConfiguration ppc (_plugins[0]->possible_output ()); + + if (ppc.size () == 0) { + return false; + } + if (!strict_io () && ppc.size () == 1) { + return false; + } + + if (strict_io () && ppc.size () == 1) { + // "stereo" is currently preferred default for instruments + if (ppc.find (2) != ppc.end ()) { + return false; + } + } + + if (ppc.size () == 1 && ppc.find (0) != ppc.end () && !_plugins[0]->get_info ()->reconfigurable_io ()) { + // some midi-sequencer (e.g. QMidiArp) or other midi-out plugin + // pretending to be an "Instrument" + return false; + } + + if (!is_instrument ()) { + return false; + } + return true; } void @@ -368,34 +451,82 @@ PluginInsert::create_automatable_parameters () { assert (!_plugins.empty()); + boost::shared_ptr plugin = _plugins.front(); set a = _plugins.front()->automatable (); - for (set::iterator i = a.begin(); i != a.end(); ++i) { - if (i->type() == PluginAutomation) { + for (uint32_t i = 0; i < plugin->parameter_count(); ++i) { + if (!plugin->parameter_is_control (i)) { + continue; + } - Evoral::Parameter param(*i); + ParameterDescriptor desc; + plugin->get_parameter_descriptor(i, desc); - ParameterDescriptor desc; - _plugins.front()->get_parameter_descriptor(i->id(), desc); + if (!plugin->parameter_is_input (i)) { + _control_outputs[i] = boost::shared_ptr (new ReadOnlyControl (plugin, desc, i)); + continue; + } + Evoral::Parameter param (PluginAutomation, 0, i); + const bool automatable = a.find(param) != a.end(); + + if (automatable) { can_automate (param); - boost::shared_ptr list(new AutomationList(param, desc)); - boost::shared_ptr c (new PluginControl(this, param, desc, list)); - add_control (c); - _plugins.front()->set_automation_control (i->id(), c); - } else if (i->type() == PluginPropertyAutomation) { - Evoral::Parameter param(*i); - const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id()); - if (desc.datatype != Variant::NOTHING) { - boost::shared_ptr list; - if (Variant::type_is_numeric(desc.datatype)) { - list = boost::shared_ptr(new AutomationList(param, desc)); - } - add_control (boost::shared_ptr (new PluginPropertyControl(this, param, desc, list))); + } + boost::shared_ptr list(new AutomationList(param, desc)); + boost::shared_ptr c (new PluginControl(this, param, desc, list)); + if (!automatable) { + c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable)); + } + add_control (c); + plugin->set_automation_control (i, c); + } + + + const Plugin::PropertyDescriptors& pdl (plugin->get_supported_properties ()); + for (Plugin::PropertyDescriptors::const_iterator p = pdl.begin(); p != pdl.end(); ++p) { + Evoral::Parameter param (PluginPropertyAutomation, 0, p->first); + const ParameterDescriptor& desc = plugin->get_property_descriptor(param.id()); + if (desc.datatype != Variant::NOTHING) { + boost::shared_ptr list; + if (Variant::type_is_numeric(desc.datatype)) { + list = boost::shared_ptr(new AutomationList(param, desc)); } + boost::shared_ptr c (new PluginPropertyControl(this, param, desc, list)); + if (!Variant::type_is_numeric(desc.datatype)) { + c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable)); + } + add_control (c); } } + + _bypass_port = plugin->designated_bypass_port (); + + /* special case VST effSetBypass */ + if (_bypass_port == UINT32_MAX -1) { + // emulate VST Bypass + Evoral::Parameter param (PluginAutomation, 0, _bypass_port); + ParameterDescriptor desc; + desc.label = _("Plugin Enable"); + desc.toggled = true; + desc.normal = 1; + desc.lower = 0; + desc.upper = 1; + boost::shared_ptr list(new AutomationList(param, desc)); + boost::shared_ptr c (new PluginControl(this, param, desc, list)); + add_control (c); + } + + if (_bypass_port != UINT32_MAX) { + boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)); + if (0 == (ac->flags () & Controllable::NotAutomatable)) { + ac->alist()->automation_state_changed.connect_same_thread (*this, boost::bind (&PluginInsert::bypassable_changed, this)); + ac->Changed.connect_same_thread (*this, boost::bind (&PluginInsert::enable_changed, this)); + } + } + plugin->PresetPortSetValue.connect_same_thread (*this, boost::bind (&PluginInsert::preset_load_set_value, this, _1, _2)); } + /** Called when something outside of this host has modified a plugin * parameter. Responsible for propagating the change to two places: * @@ -465,6 +596,17 @@ PluginInsert::activate () } Processor::activate (); + /* when setting state e.g ProcessorBox::paste_processor_state () + * the plugin is not yet owned by a route. + * but no matter. Route::add_processors() will call activate () again + */ + if (!owner ()) { + return; + } + if (_plugin_signal_latency != signal_latency ()) { + _plugin_signal_latency = signal_latency (); + latency_changed (); + } } void @@ -475,6 +617,10 @@ PluginInsert::deactivate () for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { (*i)->deactivate (); } + if (_plugin_signal_latency != signal_latency ()) { + _plugin_signal_latency = signal_latency (); + latency_changed (); + } } void @@ -486,7 +632,143 @@ PluginInsert::flush () } void -PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now) +PluginInsert::enable (bool yn) +{ + if (_bypass_port == UINT32_MAX) { + if (yn) { + activate (); + } else { + deactivate (); + } + } else { + if (!_pending_active) { + activate (); + } + boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)); + const double val = yn ? 1.0 : 0.0; + ac->set_value (val, Controllable::NoGroup); + +#ifdef ALLOW_VST_BYPASS_TO_FAIL // yet unused, see also vst_plugin.cc + /* special case VST.. bypass may fail */ + if (_bypass_port == UINT32_MAX - 1) { + /* check if bypass worked */ + if (ac->get_value () != val) { + warning << _("PluginInsert: VST Bypass failed, falling back to host bypass.") << endmsg; + // set plugin to enabled (not-byassed) + ac->set_value (1.0, Controllable::NoGroup); + // ..and use host-provided hard-bypass + if (yn) { + activate (); + } else { + deactivate (); + } + return; + } + } +#endif + ActiveChanged (); + } +} + +bool +PluginInsert::enabled () const +{ + if (_bypass_port == UINT32_MAX) { + return Processor::enabled (); + } else { + boost::shared_ptr ac = boost::const_pointer_cast (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port))); + return (ac->get_value () > 0 && _pending_active); + } +} + +bool +PluginInsert::bypassable () const +{ + if (_bypass_port == UINT32_MAX) { + return true; + } else { + boost::shared_ptr ac = boost::const_pointer_cast (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port))); + + return !ac->automation_playback (); + } +} + +void +PluginInsert::enable_changed () +{ + ActiveChanged (); +} + +void +PluginInsert::bypassable_changed () +{ + BypassableChanged (); +} + +bool +PluginInsert::write_immediate_event (size_t size, const uint8_t* buf) +{ + bool rv = true; + for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { + if (!(*i)->write_immediate_event (size, buf)) { + rv = false; + } + } + return rv; +} + +void +PluginInsert::preset_load_set_value (uint32_t p, float v) +{ + boost::shared_ptr ac = automation_control (Evoral::Parameter(PluginAutomation, 0, p)); + if (!ac) { + return; + } + + if (ac->automation_state() & Play) { + return; + } + + start_touch (p); + ac->set_value (v, Controllable::NoGroup); + end_touch (p); +} + +void +PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, samplecnt_t nframes, samplecnt_t offset) const +{ + // TODO optimize: store "unconnected" in a fixed set. + // it only changes on reconfiguration. + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + for (uint32_t out = 0; out < bufs.count().get (*t); ++out) { + bool mapped = false; + if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) { + mapped = true; // in-place Midi bypass + } + for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) { + PinMappings::const_iterator i = out_map.find (pc); + if (i == out_map.end ()) { + continue; + } + const ChanMapping& outmap (i->second); + for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) { + bool valid; + uint32_t idx = outmap.get (*t, o, &valid); + if (valid && idx == out) { + mapped = true; + break; + } + } + } + if (!mapped) { + bufs.get (*t, out).silence (nframes, offset); + } + } + } +} + +void +PluginInsert::connect_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes, samplecnt_t offset, bool with_auto) { // TODO: atomically copy maps & _no_inplace PinMappings in_map (_in_map); @@ -554,7 +836,7 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of if (c->list() && c->automation_playback()) { bool valid; - const float val = c->list()->rt_safe_eval (now, valid); + const float val = c->list()->rt_safe_eval (start, valid); if (valid) { /* This is the ONLY place where we are @@ -573,10 +855,10 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of } } - /* Calculate if, and how many frames we need to collect for analysis */ - framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max - + /* Calculate if, and how many samples we need to collect for analysis */ + samplecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max - _signal_analysis_collected_nframes); - if (nframes < collect_signal_nframes) { // we might not get all frames now + if (nframes < collect_signal_nframes) { // we might not get all samples now collect_signal_nframes = nframes; } @@ -584,12 +866,12 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of // collect input //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl; //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl; - //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl; + //std::cerr << "filling buffer with " << collect_signal_nframes << " samples at " << _signal_analysis_collected_nframes << std::endl; - _signal_analysis_inputs.set_count(internal_input_streams()); + _signal_analysis_inputs.set_count(input_streams()); - for (uint32_t i = 0; i < internal_input_streams().n_audio(); ++i) { - _signal_analysis_inputs.get_audio(i).read_from( + for (uint32_t i = 0; i < input_streams().n_audio(); ++i) { + _signal_analysis_inputs.get_audio(i).read_from ( bufs.get_audio(i), collect_signal_nframes, _signal_analysis_collected_nframes); // offset is for target buffer @@ -602,7 +884,7 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2))); ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2))); - _plugins.front()->connect_and_run (bufs, mb_in_map, mb_out_map, nframes, offset); + _plugins.front()->connect_and_run (bufs, start, end, speed, mb_in_map, mb_out_map, nframes, offset); for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) { bufs.get (DataType::AUDIO, out).silence (nframes, offset); @@ -678,7 +960,7 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of i_out_map.offset_to (*t, natural_input_streams ().get (*t)); } - if ((*i)->connect_and_run (inplace_bufs, i_in_map, i_out_map, nframes, offset)) { + if ((*i)->connect_and_run (inplace_bufs, start, end, speed, i_in_map, i_out_map, nframes, offset)) { deactivate (); } } @@ -708,34 +990,12 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of /* in-place processing */ uint32_t pc = 0; for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) { - if ((*i)->connect_and_run(bufs, in_map[pc], out_map[pc], nframes, offset)) { + if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) { deactivate (); } } - - // TODO optimize: store "unconnected" in a fixed set. - // it only changes on reconfiguration. - for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { - for (uint32_t out = 0; out < bufs.count().get (*t); ++out) { - bool mapped = false; - if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) { - mapped = true; // in-place Midi bypass - } - for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) { - for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) { - bool valid; - uint32_t idx = out_map[pc].get (*t, o, &valid); - if (valid && idx == out) { - mapped = true; - break; - } - } - } - if (!mapped) { - bufs.get (*t, out).silence (nframes, offset); - } - } - } + // now silence unconnected outputs + inplace_silence_unconnected (bufs, _out_map, nframes, offset); } if (collect_signal_nframes > 0) { @@ -743,9 +1003,9 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl; //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl; - _signal_analysis_outputs.set_count(internal_output_streams()); + _signal_analysis_outputs.set_count(output_streams()); - for (uint32_t i = 0; i < internal_output_streams().n_audio(); ++i) { + for (uint32_t i = 0; i < output_streams().n_audio(); ++i) { _signal_analysis_outputs.get_audio(i).read_from( bufs.get_audio(i), collect_signal_nframes, @@ -763,12 +1023,131 @@ PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t of &_signal_analysis_outputs); } } + + if (_plugin_signal_latency != signal_latency ()) { + _plugin_signal_latency = signal_latency (); + latency_changed (); + } } void -PluginInsert::silence (framecnt_t nframes) +PluginInsert::bypass (BufferSet& bufs, pframes_t nframes) { + /* bypass the plugin(s) not the whole processor. + * -> use mappings just like connect_and_run + */ + + // TODO: atomically copy maps & _no_inplace + const ChanMapping in_map (no_sc_input_map ()); + const ChanMapping out_map (output_map ()); + if (_mapping_changed) { + _no_inplace = check_inplace (); + _mapping_changed = false; + } + + bufs.set_count(ChanCount::max(bufs.count(), _configured_internal)); + bufs.set_count(ChanCount::max(bufs.count(), _configured_out)); + + if (_no_inplace) { + ChanMapping thru_map (_thru_map); + + BufferSet& inplace_bufs = _session.get_noinplace_buffers(); + // copy all inputs + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) { + inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0); + } + } + ARDOUR::ChanMapping used_outputs; + // copy thru + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + for (uint32_t out = 0; out < _configured_out.get (*t); ++out) { + bool valid; + uint32_t in_idx = thru_map.get (*t, out, &valid); + if (valid) { + bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0); + used_outputs.set (*t, out, 1); // mark as used + } + } + } + // plugin no-op: assume every plugin has an internal identity map + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + for (uint32_t out = 0; out < _configured_out.get (*t); ++out) { + bool valid; + uint32_t src_idx = out_map.get_src (*t, out, &valid); + if (!valid) { + continue; + } + uint32_t in_idx = in_map.get (*t, src_idx, &valid); + if (!valid) { + continue; + } + bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0); + used_outputs.set (*t, out, 1); // mark as used + } + } + // now silence all unused outputs + if (has_midi_bypass ()) { + used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass. + } + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + for (uint32_t out = 0; out < _configured_out.get (*t); ++out) { + bool valid; + used_outputs.get (*t, out, &valid); + if (!valid) { + bufs.get (*t, out).silence (nframes, 0); + } + } + } + } else { + if (_match.method == Split) { + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + if (_configured_internal.get (*t) == 0) { + continue; + } + // copy/feeds _all_ *connected* inputs, copy the first buffer + bool valid; + uint32_t first_idx = in_map.get (*t, 0, &valid); + assert (valid && first_idx == 0); // check_inplace ensures this + for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) { + uint32_t idx = in_map.get (*t, i, &valid); + if (valid) { + assert (idx == 0); + bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0); + } + } + } + } + + // apply output map and/or monotonic but not identity i/o mappings + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + for (uint32_t out = 0; out < _configured_out.get (*t); ++out) { + bool valid; + uint32_t src_idx = out_map.get_src (*t, out, &valid); + if (!valid) { + bufs.get (*t, out).silence (nframes, 0); + continue; + } + uint32_t in_idx = in_map.get (*t, src_idx, &valid); + if (!valid) { + bufs.get (*t, out).silence (nframes, 0); + continue; + } + if (in_idx != src_idx) { + bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0); + } + } + } + } +} + +void +PluginInsert::silence (samplecnt_t nframes, samplepos_t start_sample) +{ + automation_run (start_sample, nframes); // evaluate automation only + if (!active ()) { + // XXX delaybuffers need to be offset by nframes return; } @@ -780,63 +1159,40 @@ PluginInsert::silence (framecnt_t nframes) #ifdef MIXBUS if (is_channelstrip ()) { if (_configured_in.n_audio() > 0) { - _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0); + _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0); } } else #endif for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { - (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0); + (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0); } } void -PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool) +PluginInsert::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool) { + if (_sidechain) { + // collect sidechain input for complete cycle (!) + // TODO we need delaylines here for latency compensation + _sidechain->run (bufs, start_sample, end_sample, speed, nframes, true); + } + if (_pending_active) { /* run as normal if we are active or moving from inactive to active */ - if (_sidechain) { - // collect sidechain input for complete cycle (!) - // TODO we need delaylines here for latency compensation - _sidechain->run (bufs, start_frame, end_frame, nframes, true); - } - if (_session.transport_rolling() || _session.bounce_processing()) { - automation_run (bufs, start_frame, nframes); + automate_and_run (bufs, start_sample, end_sample, speed, nframes); } else { - connect_and_run (bufs, nframes, 0, false); + Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK); + connect_and_run (bufs, start_sample, end_sample, speed, nframes, 0, lm.locked()); } } else { - // TODO use mapping in bypassed mode ?! - // -> do we bypass the processor or the plugin - - // TODO include sidechain?? - - uint32_t in = input_streams ().n_audio (); - uint32_t out = output_streams().n_audio (); - - if (has_no_audio_inputs() || in == 0) { - - /* silence all (audio) outputs. Should really declick - * at the transitions of "active" - */ - - for (uint32_t n = 0; n < out; ++n) { - bufs.get_audio (n).silence (nframes); - } - - } else if (out > in) { - - /* not active, but something has make up for any channel count increase - * for now , simply replicate last buffer - */ - for (uint32_t n = in; n < out; ++n) { - bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes); - } - } - - bufs.count().set_audio (out); + // XXX should call ::silence() to run plugin(s) for consistent load. + // We'll need to change this anyway when bypass can be automated + bypass (bufs, nframes); + automation_run (start_sample, nframes); // evaluate automation only + _delaybuffers.flush (); } _active = _pending_active; @@ -847,39 +1203,37 @@ PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame } void -PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes) +PluginInsert::automate_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes) { Evoral::ControlEvent next_event (0, 0.0f); - framepos_t now = start; - framepos_t end = now + nframes; - framecnt_t offset = 0; + samplecnt_t offset = 0; Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK); if (!lm.locked()) { - connect_and_run (bufs, nframes, offset, false); + connect_and_run (bufs, start, end, speed, nframes, offset, false); return; } - if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) { + if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) { /* no events have a time within the relevant range */ - connect_and_run (bufs, nframes, offset, true, now); + connect_and_run (bufs, start, end, speed, nframes, offset, true); return; } while (nframes) { - framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes); + samplecnt_t cnt = min (((samplecnt_t) ceil (next_event.when) - start), (samplecnt_t) nframes); - connect_and_run (bufs, cnt, offset, true, now); + connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed nframes -= cnt; offset += cnt; - now += cnt; + start += cnt; - if (!find_next_event (now, end, next_event)) { + if (!find_next_event (start, end, next_event)) { break; } } @@ -887,7 +1241,7 @@ PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nfram /* cleanup anything that is left to do */ if (nframes) { - connect_and_run (bufs, nframes, offset, true, now); + connect_and_run (bufs, start, start + nframes, speed, nframes, offset, true); } } @@ -983,6 +1337,9 @@ PluginInsert::plugin_factory (boost::shared_ptr other) #ifdef LXVST_SUPPORT boost::shared_ptr lxvp; #endif +#ifdef MACVST_SUPPORT + boost::shared_ptr mvp; +#endif #ifdef AUDIOUNIT_SUPPORT boost::shared_ptr ap; #endif @@ -1003,6 +1360,10 @@ PluginInsert::plugin_factory (boost::shared_ptr other) } else if ((lxvp = boost::dynamic_pointer_cast (other)) != 0) { return boost::shared_ptr (new LXVSTPlugin (*lxvp)); #endif +#ifdef MACVST_SUPPORT + } else if ((mvp = boost::dynamic_pointer_cast (other)) != 0) { + return boost::shared_ptr (new MacVSTPlugin (*mvp)); +#endif #ifdef AUDIOUNIT_SUPPORT } else if ((ap = boost::dynamic_pointer_cast (other)) != 0) { return boost::shared_ptr (new AUPlugin (*ap)); @@ -1056,6 +1417,20 @@ PluginInsert::set_thru_map (ChanMapping m) { } } +bool +PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out, + const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm) +{ + if (_configured) { return false; } + _configured_in = in; + _configured_out = out; + _in_map[0] = im; + _out_map[0] = om; + _thru_map = tm; + _maps_from_state = in.n_total () > 0 && out.n_total () > 0; + return true; +} + ChanMapping PluginInsert::input_map () const { @@ -1073,6 +1448,27 @@ PluginInsert::input_map () const return rv; } + +ChanMapping +PluginInsert::no_sc_input_map () const +{ + ChanMapping rv; + uint32_t pc = 0; + for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) { + ChanMapping m (i->second); + const ChanMapping::Mappings& mp ((*i).second.mappings()); + for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) { + uint32_t ins = natural_input_streams().get(tm->first) - _cached_sidechain_pins.get(tm->first); + for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) { + if (i->first < ins) { + rv.set (tm->first, i->first + pc * ins, i->second); + } + } + } + } + return rv; +} + ChanMapping PluginInsert::output_map () const { @@ -1180,6 +1576,30 @@ PluginInsert::check_inplace () inplace_ok = false; } } + + if (inplace_ok) { + /* check if every output is fed by the corresponding input + * + * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2 + * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1) + * + * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1 + */ + ChanMapping in_map (input_map ()); + const ChanMapping::Mappings out_m (output_map ().mappings ()); + for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) { + for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) { + /* src-pin: c->first, out-port: c->second */ + bool valid; + uint32_t in_port = in_map.get (t->first, c->first, &valid); + if (valid && in_port != c->second) { + inplace_ok = false; + break; + } + } + } + } + DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing")); return !inplace_ok; // no-inplace } @@ -1368,7 +1788,9 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) ChanCount old_in; ChanCount old_internal; ChanCount old_out; + ChanCount old_pins; + old_pins = natural_input_streams(); old_in = _configured_in; old_out = _configured_out; old_internal = _configured_internal; @@ -1422,8 +1844,12 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) break; case Delegate: { - ChanCount dout (in); // hint + ChanCount din (_configured_internal); + ChanCount dout (din); // hint if (_custom_cfg) { + if (_custom_sinks.n_total () > 0) { + din = _custom_sinks; + } dout = _custom_out; } else if (_preset_out.n_audio () > 0) { dout.set (DataType::AUDIO, _preset_out.n_audio ()); @@ -1432,10 +1858,11 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) } if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); } ChanCount useins; - bool const r = _plugins.front()->can_support_io_configuration (_configured_internal, dout, &useins); + DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout)); + bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins); assert (r); if (useins.n_audio() == 0) { - useins = _configured_internal; + useins = din; } DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout)); @@ -1444,6 +1871,9 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) _configured = false; return false; } + if (!_custom_cfg) { + _custom_sinks = din; + } } break; default: @@ -1455,13 +1885,15 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) break; } - DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: cfg:%2 state:%3 chn-in:%4 chn-out:%5 match:%6 size-in:%7 size-out:%8\n", + DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: cfg:%2 state:%3 chn-in:%4 chn-out:%5 inpin:%6 match:%7 cust:%8 size-in:%9 size-out:%10\n", name (), _configured ? "Y" : "N", _maps_from_state ? "Y" : "N", old_in == in ? "==" : "!=", old_out == out ? "==" : "!=", + old_pins == natural_input_streams () ? "==" : "!=", old_match.method == _match.method ? "==" : "!=", + old_match.custom_cfg == _match.custom_cfg ? "==" : "!=", _in_map.size() == get_count () ? "==" : "!=", _out_map.size() == get_count () ? "==" : "!=" )); @@ -1469,17 +1901,16 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) bool mapping_changed = false; if (old_in == in && old_out == out && _configured + && old_pins == natural_input_streams () && old_match.method == _match.method + && old_match.custom_cfg == _match.custom_cfg && _in_map.size() == _out_map.size() && _in_map.size() == get_count () ) { - assert (_maps_from_state == false); /* If the configuration has not changed, keep the mapping */ - if (old_internal != _configured_internal) { - mapping_changed = sanitize_maps (); - } + mapping_changed = sanitize_maps (); } else if (_match.custom_cfg && _configured) { - assert (_maps_from_state == false); + /* don't touch the map in manual mode */ mapping_changed = sanitize_maps (); } else { #ifdef MIXBUS @@ -1563,6 +1994,7 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ())); if (old_in != in || old_out != out || old_internal != _configured_internal + || old_pins != natural_input_streams () || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split)) ) { PluginIoReConfigure (); /* EMIT SIGNAL */ @@ -1576,10 +2008,10 @@ PluginInsert::configure_io (ChanCount in, ChanCount out) // buffers and the analyser makes sure it gets enough data for the // analysis window session().ensure_buffer_set (_signal_analysis_inputs, in); - //_signal_analysis_inputs.set_count (in); + _signal_analysis_inputs.set_count (in); session().ensure_buffer_set (_signal_analysis_outputs, out); - //_signal_analysis_outputs.set_count (out); + _signal_analysis_outputs.set_count (out); // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl; @@ -1644,7 +2076,7 @@ PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, Chan PluginInfoPtr info = _plugins.front()->get_info(); out = _custom_out; if (info->reconfigurable_io()) { - return Match (Delegate, get_count(), _strict_io, true); + return Match (Delegate, 1, _strict_io, true); } else { return Match (ExactMatch, get_count(), _strict_io, true); } @@ -1662,7 +2094,7 @@ PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, Chan m.strict_io = true; /* special case MIDI instruments */ - if (needs_midi_input ()) { + if (is_instrument ()) { // output = midi-bypass + at most master-out channels. ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out max_out.set (DataType::MIDI, out.get(DataType::MIDI)); @@ -1713,6 +2145,8 @@ PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, Chan // houston, we have a problem. return Match (Impossible, 0); } + // midi bypass + if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); } return Match (Delegate, 1, _strict_io); } @@ -1781,6 +2215,8 @@ PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, Cha if (!r) { return Match (Impossible, 0); } + // midi bypass + if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); } return Match (Delegate, 1); } @@ -1834,7 +2270,7 @@ PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, Cha uint32_t f = 0; bool can_replicate = true; - for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) { + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { // ignore side-chains uint32_t nin = ns_inputs.get (*t); @@ -1922,28 +2358,23 @@ PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, Cha XMLNode& -PluginInsert::get_state () +PluginInsert::state () { - return state (true); -} - -XMLNode& -PluginInsert::state (bool full) -{ - XMLNode& node = Processor::state (full); + XMLNode& node = Processor::state (); - node.add_property("type", _plugins[0]->state_node_name()); - node.add_property("unique-id", _plugins[0]->unique_id()); - node.add_property("count", string_compose("%1", _plugins.size())); + node.set_property("type", _plugins[0]->state_node_name()); + node.set_property("unique-id", _plugins[0]->unique_id()); + node.set_property("count", (uint32_t)_plugins.size()); /* remember actual i/o configuration (for later placeholder * in case the plugin goes missing) */ node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput"))); + node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks"))); node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput"))); node.add_child_nocopy (* _preset_out.state (X_("PresetOutput"))); /* save custom i/o config */ - node.add_property("custom", _custom_cfg ? "yes" : "no"); + node.set_property("custom", _custom_cfg); for (uint32_t pc = 0; pc < get_count(); ++pc) { char tmp[128]; snprintf (tmp, sizeof(tmp), "InputMap-%d", pc); @@ -1954,7 +2385,7 @@ PluginInsert::state (bool full) node.add_child_nocopy (* _thru_map.state ("ThruMap")); if (_sidechain) { - node.add_child_nocopy (_sidechain->state (full)); + node.add_child_nocopy (_sidechain->get_state ()); } _plugins[0]->set_insert_id(this->id()); @@ -1979,19 +2410,19 @@ PluginInsert::set_control_ids (const XMLNode& node, int version) for (iter = nlist.begin(); iter != nlist.end(); ++iter) { if ((*iter)->name() == Controllable::xml_node_name) { - const XMLProperty* prop; uint32_t p = (uint32_t)-1; #ifdef LV2_SUPPORT - if ((prop = (*iter)->property (X_("symbol"))) != 0) { + std::string str; + if ((*iter)->get_property (X_("symbol"), str)) { boost::shared_ptr lv2plugin = boost::dynamic_pointer_cast (_plugins[0]); if (lv2plugin) { - p = lv2plugin->port_index(prop->value().c_str()); + p = lv2plugin->port_index(str.c_str()); } } #endif - if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) { - p = atoi (prop->value()); + if (p == (uint32_t)-1) { + (*iter)->get_property (X_("parameter"), p); } if (p != (uint32_t)-1) { @@ -2020,40 +2451,38 @@ PluginInsert::set_state(const XMLNode& node, int version) XMLNodeList nlist = node.children(); XMLNodeIterator niter; XMLPropertyList plist; - const XMLProperty *prop; ARDOUR::PluginType type; - if ((prop = node.property ("type")) == 0) { + std::string str; + if (!node.get_property ("type", str)) { error << _("XML node describing plugin is missing the `type' field") << endmsg; return -1; } - if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */ + if (str == X_("ladspa") || str == X_("Ladspa")) { /* handle old school sessions */ type = ARDOUR::LADSPA; - } else if (prop->value() == X_("lv2")) { + } else if (str == X_("lv2")) { type = ARDOUR::LV2; - } else if (prop->value() == X_("windows-vst")) { + } else if (str == X_("windows-vst")) { type = ARDOUR::Windows_VST; - } else if (prop->value() == X_("lxvst")) { + } else if (str == X_("lxvst")) { type = ARDOUR::LXVST; - } else if (prop->value() == X_("audiounit")) { + } else if (str == X_("mac-vst")) { + type = ARDOUR::MacVST; + } else if (str == X_("audiounit")) { type = ARDOUR::AudioUnit; - } else if (prop->value() == X_("luaproc")) { + } else if (str == X_("luaproc")) { type = ARDOUR::Lua; } else { - error << string_compose (_("unknown plugin type %1 in plugin insert state"), - prop->value()) - << endmsg; + error << string_compose (_("unknown plugin type %1 in plugin insert state"), str) << endmsg; return -1; } - prop = node.property ("unique-id"); + XMLProperty const * prop = node.property ("unique-id"); if (prop == 0) { #ifdef WINDOWS_VST_SUPPORT - /* older sessions contain VST plugins with only an "id" field. - */ - + /* older sessions contain VST plugins with only an "id" field. */ if (type == ARDOUR::Windows_VST) { prop = node.property ("id"); } @@ -2061,11 +2490,11 @@ PluginInsert::set_state(const XMLNode& node, int version) #ifdef LXVST_SUPPORT /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/ - if (type == ARDOUR::LXVST) { prop = node.property ("id"); } #endif + /* recheck */ if (prop == 0) { @@ -2075,23 +2504,47 @@ PluginInsert::set_state(const XMLNode& node, int version) } boost::shared_ptr plugin = find_plugin (_session, prop->value(), type); + bool any_vst = false; - /* treat linux and windows VST plugins equivalent if they have the same uniqueID + /* treat VST plugins equivalent if they have the same uniqueID * allow to move sessions windows <> linux */ #ifdef LXVST_SUPPORT - if (plugin == 0 && type == ARDOUR::Windows_VST) { + if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::MacVST)) { type = ARDOUR::LXVST; plugin = find_plugin (_session, prop->value(), type); + if (plugin) { any_vst = true; } } #endif #ifdef WINDOWS_VST_SUPPORT - if (plugin == 0 && type == ARDOUR::LXVST) { + if (plugin == 0 && (type == ARDOUR::LXVST || type == ARDOUR::MacVST)) { type = ARDOUR::Windows_VST; plugin = find_plugin (_session, prop->value(), type); + if (plugin) { any_vst = true; } } #endif +#ifdef MACVST_SUPPORT + if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::LXVST)) { + type = ARDOUR::MacVST; + plugin = find_plugin (_session, prop->value(), type); + if (plugin) { any_vst = true; } + } +#endif + + if (plugin == 0 && type == ARDOUR::Lua) { + /* unique ID (sha1 of script) was not found, + * load the plugin from the serialized version in the + * session-file instead. + */ + boost::shared_ptr lp (new LuaProc (_session.engine(), _session, "")); + XMLNode *ls = node.child (lp->state_node_name().c_str()); + if (ls && lp) { + lp->set_script_from_state (*ls); + plugin = lp; + } + } + if (plugin == 0) { error << string_compose( _("Found a reference to a plugin (\"%1\") that is unknown.\n" @@ -2101,15 +2554,6 @@ PluginInsert::set_state(const XMLNode& node, int version) return -1; } - if (type == ARDOUR::Lua) { - XMLNode *ls = node.child (plugin->state_node_name().c_str()); - // we need to load the script to set the name and parameters. - boost::shared_ptr lp = boost::dynamic_pointer_cast(plugin); - if (ls && lp) { - lp->set_script_from_state (*ls); - } - } - // The name of the PluginInsert comes from the plugin, nothing else _name = plugin->get_info()->name; @@ -2131,9 +2575,7 @@ PluginInsert::set_state(const XMLNode& node, int version) set_control_ids (node, version); } - if ((prop = node.property ("count")) != 0) { - sscanf (prop->value().c_str(), "%u", &count); - } + node.get_property ("count", count); if (_plugins.size() != count) { for (uint32_t n = 1; n < count; ++n) { @@ -2146,9 +2588,7 @@ PluginInsert::set_state(const XMLNode& node, int version) PBD::ID new_id = this->id(); PBD::ID old_id = this->id(); - if ((prop = node.property ("id")) != 0) { - old_id = prop->value (); - } + node.get_property ("id", old_id); for (niter = nlist.begin(); niter != nlist.end(); ++niter) { @@ -2156,7 +2596,9 @@ PluginInsert::set_state(const XMLNode& node, int version) and set all plugins to the same state. */ - if ((*niter)->name() == plugin->state_node_name()) { + if ( ((*niter)->name() == plugin->state_node_name()) + || (any_vst && ((*niter)->name() == "lxvst" || (*niter)->name() == "windows-vst" || (*niter)->name() == "mac-vst")) + ) { for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { /* Plugin state can include external files which are named after the ID. @@ -2182,6 +2624,14 @@ PluginInsert::set_state(const XMLNode& node, int version) } } + /* when copying plugin state, notify UI */ + for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr c = boost::dynamic_pointer_cast (li->second); + if (c) { + c->Changed (false, Controllable::NoGroup); /* EMIT SIGNAL */ + } + } + break; } } @@ -2203,9 +2653,7 @@ PluginInsert::set_state(const XMLNode& node, int version) set_parameter_state_2X (node, version); } - if ((prop = node.property (X_("custom"))) != 0) { - _custom_cfg = string_is_affirmative (prop->value()); - } + node.get_property (X_("custom"), _custom_cfg); uint32_t in_maps = 0; uint32_t out_maps = 0; @@ -2214,6 +2662,9 @@ PluginInsert::set_state(const XMLNode& node, int version) if ((*i)->name() == X_("ConfiguredInput")) { _configured_in = ChanCount(**i); } + if ((*i)->name() == X_("CustomSinks")) { + _custom_sinks = ChanCount(**i); + } if ((*i)->name() == X_("ConfiguredOutput")) { _custom_out = ChanCount(**i); _configured_out = ChanCount(**i); @@ -2223,14 +2674,14 @@ PluginInsert::set_state(const XMLNode& node, int version) } if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) { long pc = atol (&((*i)->name().c_str()[9])); - if (pc >=0 && pc <= get_count()) { + if (pc >= 0 && pc <= (long) get_count()) { _in_map[pc] = ChanMapping (**i); ++in_maps; } } if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) { long pc = atol (&((*i)->name().c_str()[10])); - if (pc >=0 && pc <= get_count()) { + if (pc >= 0 && pc <= (long) get_count()) { _out_map[pc] = ChanMapping (**i); ++out_maps; } @@ -2244,7 +2695,9 @@ PluginInsert::set_state(const XMLNode& node, int version) if (!_sidechain) { add_sidechain (0); } - _sidechain->set_state (**i, version); + if (!regenerate_xml_or_string_ids ()) { + _sidechain->set_state (**i, version); + } } } @@ -2273,6 +2726,15 @@ PluginInsert::update_id (PBD::ID id) } } +void +PluginInsert::set_owner (SessionObject* o) +{ + Processor::set_owner (o); + for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { + (*i)->set_owner (o); + } +} + void PluginInsert::set_state_dir (const std::string& d) { @@ -2295,10 +2757,8 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) } XMLNodeList cnodes; - XMLProperty *cprop; XMLNodeConstIterator iter; XMLNode *child; - const char *port; uint32_t port_id; cnodes = (*niter)->children ("port"); @@ -2307,15 +2767,11 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) child = *iter; - if ((cprop = child->property("number")) != 0) { - port = cprop->value().c_str(); - } else { + if (!child->get_property("number", port_id)) { warning << _("PluginInsert: Auto: no ladspa port number") << endmsg; continue; } - sscanf (port, "%" PRIu32, &port_id); - if (port_id >= _plugins[0]->parameter_count()) { warning << _("PluginInsert: Auto: port id out of range") << endmsg; continue; @@ -2327,30 +2783,6 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) if (c && c->alist()) { if (!child->children().empty()) { c->alist()->set_state (*child->children().front(), version); - - /* In some cases 2.X saves lists with min_yval and max_yval - being FLT_MIN and FLT_MAX respectively. This causes problems - in A3 because these min/max values are used to compute - where GUI control points should be drawn. If we see such - values, `correct' them to the min/max of the appropriate - parameter. - */ - - float min_y = c->alist()->get_min_y (); - float max_y = c->alist()->get_max_y (); - - ParameterDescriptor desc; - _plugins.front()->get_parameter_descriptor (port_id, desc); - - if (min_y == FLT_MIN) { - min_y = desc.lower; - } - - if (max_y == FLT_MAX) { - max_y = desc.upper; - } - - c->alist()->set_yrange (min_y, max_y); } } else { error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg; @@ -2363,6 +2795,16 @@ PluginInsert::set_parameter_state_2X (const XMLNode& node, int version) } } +boost::shared_ptr +PluginInsert::control_output (uint32_t num) const +{ + CtrlOutMap::const_iterator i = _control_outputs.find (num); + if (i == _control_outputs.end ()) { + return boost::shared_ptr (); + } else { + return (*i).second; + } +} string PluginInsert::describe_parameter (Evoral::Parameter param) @@ -2378,9 +2820,12 @@ PluginInsert::describe_parameter (Evoral::Parameter param) return Automatable::describe_parameter(param); } -ARDOUR::framecnt_t +ARDOUR::samplecnt_t PluginInsert::signal_latency() const { + if (!_pending_active) { + return 0; + } if (_user_latency) { return _user_latency; } @@ -2402,34 +2847,16 @@ PluginInsert::PluginControl::PluginControl (PluginInsert* p, , _plugin (p) { if (alist()) { - alist()->reset_default (desc.normal); if (desc.toggled) { list->set_interpolation(Evoral::ControlList::Discrete); } } - - if (desc.toggled) { - set_flags(Controllable::Toggle); - } } /** @param val `user' value */ -void -PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override) -{ - if (writable()) { - _set_value (user_val, group_override); - } -} -void -PluginInsert::PluginControl::set_value_unchecked (double user_val) -{ - /* used only by automation playback */ - _set_value (user_val, Controllable::NoGroup); -} void -PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override) +PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override) { /* FIXME: probably should be taking out some lock here.. */ @@ -2442,27 +2869,24 @@ PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::Gro iasp->set_parameter (_list->parameter().id(), user_val); } - AutomationControl::set_value (user_val, group_override); + AutomationControl::actually_set_value (user_val, group_override); } void PluginInsert::PluginControl::catch_up_with_external_value (double user_val) { - AutomationControl::set_value (user_val, Controllable::NoGroup); + AutomationControl::actually_set_value (user_val, Controllable::NoGroup); } XMLNode& PluginInsert::PluginControl::get_state () { - stringstream ss; - XMLNode& node (AutomationControl::get_state()); - ss << parameter().id(); - node.add_property (X_("parameter"), ss.str()); + node.set_property (X_("parameter"), parameter().id()); #ifdef LV2_SUPPORT boost::shared_ptr lv2plugin = boost::dynamic_pointer_cast (_plugin->_plugins[0]); if (lv2plugin) { - node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id())); + node.set_property (X_("symbol"), lv2plugin->port_symbol (parameter().id())); } #endif @@ -2489,26 +2913,10 @@ PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* : AutomationControl (p->session(), param, desc, list) , _plugin (p) { - if (alist()) { - alist()->set_yrange (desc.lower, desc.upper); - alist()->reset_default (desc.normal); - } - - if (desc.toggled) { - set_flags(Controllable::Toggle); - } -} - -void -PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/) -{ - if (writable()) { - set_value_unchecked (user_val); - } } void -PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val) +PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd) { /* Old numeric set_value(), coerce to appropriate datatype if possible. This is lossy, but better than nothing until Ardour's automation system @@ -2524,17 +2932,15 @@ PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val) } _value = value; - AutomationControl::set_value (user_val, Controllable::NoGroup); + + AutomationControl::actually_set_value (user_val, gcd); } XMLNode& PluginInsert::PluginPropertyControl::get_state () { - stringstream ss; - XMLNode& node (AutomationControl::get_state()); - ss << parameter().id(); - node.add_property (X_("property"), ss.str()); + node.set_property (X_("property"), parameter().id()); node.remove_property (X_("value")); return node; @@ -2555,7 +2961,15 @@ PluginInsert::get_impulse_analysis_plugin() // during init() -- most notably block_size.. // not great. ret = plugin_factory(_plugins[0]); - ret->configure_io (internal_input_streams (), internal_output_streams ()); + ChanCount out (internal_output_streams ()); + if (ret->get_info ()->reconfigurable_io ()) { + // populate get_info ()->n_inputs and ->n_outputs + ChanCount useins; + ret->can_support_io_configuration (internal_input_streams (), out, &useins); + assert (out == internal_output_streams ()); + } + ret->configure_io (internal_input_streams (), out); + ret->set_owner (_owner); _impulseAnalysisPlugin = ret; } else { ret = _impulseAnalysisPlugin.lock(); @@ -2565,12 +2979,12 @@ PluginInsert::get_impulse_analysis_plugin() } void -PluginInsert::collect_signal_for_analysis (framecnt_t nframes) +PluginInsert::collect_signal_for_analysis (samplecnt_t nframes) { // called from outside the audio thread, so this should be safe // only do audio as analysis is (currently) only for audio plugins - _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, internal_input_streams().n_audio(), nframes); - _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes); + _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes); + _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes); _signal_analysis_collected_nframes = 0; _signal_analysis_collect_nframes_max = nframes; @@ -2581,6 +2995,7 @@ void PluginInsert::add_plugin (boost::shared_ptr plugin) { plugin->set_insert_id (this->id()); + plugin->set_owner (_owner); if (_plugins.empty()) { /* first (and probably only) plugin instance - connect to relevant signals */ @@ -2588,7 +3003,7 @@ PluginInsert::add_plugin (boost::shared_ptr plugin) plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2)); plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1)); plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1)); - plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2)); + _custom_sinks = plugin->get_info()->n_inputs; // cache sidechain port count _cached_sidechain_pins.reset (); const ChanCount& nis (plugin->get_info()->n_inputs); @@ -2601,15 +3016,28 @@ PluginInsert::add_plugin (boost::shared_ptr plugin) } } } -#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT) +#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT) boost::shared_ptr vst = boost::dynamic_pointer_cast (plugin); if (vst) { vst->set_insert (this, _plugins.size ()); } #endif + _plugins.push_back (plugin); } +bool +PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr) +{ + bool ok = true; + for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) { + if (! (*i)->load_preset (pr)) { + ok = false; + } + } + return ok; +} + void PluginInsert::realtime_handle_transport_stopped () { @@ -2635,28 +3063,33 @@ PluginInsert::monitoring_changed () } void -PluginInsert::latency_changed (framecnt_t, framecnt_t) +PluginInsert::latency_changed () { // this is called in RT context, LatencyChanged is emitted after run() _latency_changed = true; + // XXX This also needs a proper API not an owner() hack. + assert (owner ()); + static_cast(owner ())->processor_latency_changed (); /* EMIT SIGNAL */ } void PluginInsert::start_touch (uint32_t param_id) { - boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id)); - if (ac) { - ac->start_touch (session().audible_frame()); - } + boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id)); + if (ac) { + // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0 + ac->start_touch (session().audible_sample()); + } } void PluginInsert::end_touch (uint32_t param_id) { - boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id)); - if (ac) { - ac->stop_touch (true, session().audible_frame()); - } + boost::shared_ptr ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id)); + if (ac) { + // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0 + ac->stop_touch (session().audible_sample()); + } } std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)