#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
#include "ardour/session.h"
#include "ardour/types.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
: 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)
, _strict_io (false)
, _custom_cfg (false)
, _maps_from_state (false)
+ , _latency_changed (false)
+ , _bypass_port (UINT32_MAX)
{
/* the first is the master */
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 ());
}
}
}
}
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";
_sidechain = boost::shared_ptr<SideChain> (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;
}
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
return false;
}
}
- if (!needs_midi_input ()) {
+
+ 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;
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);
add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
}
}
+
+ _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<AutomationList> list(new AutomationList(param, desc));
+ boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
+ add_control (c);
+ }
+
+ if (_bypass_port != UINT32_MAX) {
+ boost::shared_ptr<AutomationControl> 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:
*
}
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
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
}
}
+void
+PluginInsert::enable (bool yn)
+{
+ if (_bypass_port == UINT32_MAX) {
+ if (yn) {
+ activate ();
+ } else {
+ deactivate ();
+ }
+ } else {
+ if (!_pending_active) {
+ activate ();
+ }
+ boost::shared_ptr<AutomationControl> 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<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (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<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
+
+ return !ac->automation_playback ();
+ }
+}
+
+void
+PluginInsert::enable_changed ()
+{
+ ActiveChanged ();
+}
+
+void
+PluginInsert::bypassable_changed ()
+{
+ BypassableChanged ();
+}
+
+void
+PluginInsert::preset_load_set_value (uint32_t p, float v)
+{
+ boost::shared_ptr<AutomationControl> 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, framecnt_t nframes, framecnt_t offset) const
{
&_signal_analysis_outputs);
}
}
+
+ if (_plugin_signal_latency != signal_latency ()) {
+ _plugin_signal_latency = signal_latency ();
+ latency_changed ();
+ }
}
void
*/
// TODO: atomically copy maps & _no_inplace
- ChanMapping in_map (input_map ());
- ChanMapping out_map (output_map ());
+ const ChanMapping in_map (no_sc_input_map ());
+ const ChanMapping out_map (output_map ());
if (_mapping_changed) {
_no_inplace = check_inplace ();
_mapping_changed = false;
#ifdef MIXBUS
if (is_channelstrip ()) {
if (_configured_in.n_audio() > 0) {
- _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0 in_map, out_map, nframes);
+ _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
}
} else
#endif
void
PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, 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_frame, end_frame, 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, speed, nframes, true);
- }
-
if (_session.transport_rolling() || _session.bounce_processing()) {
automation_run (bufs, start_frame, end_frame, speed, nframes);
} else {
- connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, false);
+ Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
+ connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, lm.locked());
}
} else {
#ifdef LXVST_SUPPORT
boost::shared_ptr<LXVSTPlugin> lxvp;
#endif
+#ifdef MACVST_SUPPORT
+ boost::shared_ptr<MacVSTPlugin> mvp;
+#endif
#ifdef AUDIOUNIT_SUPPORT
boost::shared_ptr<AUPlugin> ap;
#endif
} else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
#endif
+#ifdef MACVST_SUPPORT
+ } else if ((mvp = boost::dynamic_pointer_cast<MacVSTPlugin> (other)) != 0) {
+ return boost::shared_ptr<Plugin> (new MacVSTPlugin (*mvp));
+#endif
#ifdef AUDIOUNIT_SUPPORT
} else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
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
{
&& _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 */
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 {
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));
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);
type = ARDOUR::Windows_VST;
} else if (prop->value() == X_("lxvst")) {
type = ARDOUR::LXVST;
+ } else if (prop->value() == X_("mac-vst")) {
+ type = ARDOUR::MacVST;
} else if (prop->value() == X_("audiounit")) {
type = ARDOUR::AudioUnit;
} else if (prop->value() == X_("luaproc")) {
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");
}
#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) {
boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
- /* 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);
}
#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);
}
#endif
+#ifdef MACVST_SUPPORT
+ if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::LXVST)) {
+ type = ARDOUR::MacVST;
+ plugin = find_plugin (_session, prop->value(), type);
+ }
+#endif
+
if (plugin == 0 && type == ARDOUR::Lua) {
/* unique ID (sha1 of script) was not found,
* load the plugin from the serialized version in the
}
}
+ /* when copying plugin state, notify UI */
+ for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li) {
+ boost::shared_ptr<PBD::Controllable> c = boost::dynamic_pointer_cast<PBD::Controllable> (li->second);
+ if (c) {
+ c->Changed (false, Controllable::NoGroup); /* EMIT SIGNAL */
+ }
+ }
+
break;
}
}
if (!_sidechain) {
add_sidechain (0);
}
- _sidechain->set_state (**i, version);
+ if (!regenerate_xml_or_string_ids ()) {
+ _sidechain->set_state (**i, version);
+ }
}
}
}
}
+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)
{
ARDOUR::framecnt_t
PluginInsert::signal_latency() const
{
+ if (!_pending_active) {
+ return 0;
+ }
if (_user_latency) {
return _user_latency;
}
// 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();
PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
{
plugin->set_insert_id (this->id());
+ plugin->set_owner (_owner);
if (_plugins.empty()) {
/* first (and probably only) plugin instance - connect to relevant signals */
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 ();
}
}
}
-#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT)
boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
if (vst) {
vst->set_insert (this, _plugins.size ());
}
#endif
+
_plugins.push_back (plugin);
}
}
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<Route*>(owner ())->processor_latency_changed (); /* EMIT SIGNAL */
}
void
PluginInsert::start_touch (uint32_t param_id)
{
- boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
- if (ac) {
- ac->start_touch (session().audible_frame());
- }
+ boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
+ if (ac) {
+ // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0
+ ac->start_touch (session().audible_frame());
+ }
}
void
PluginInsert::end_touch (uint32_t param_id)
{
- boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
- if (ac) {
- ac->stop_touch (true, session().audible_frame());
- }
+ boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
+ if (ac) {
+ // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0
+ ac->stop_touch (true, session().audible_frame());
+ }
}
std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
projects / ardour.git / blobdiff