#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"
#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;
PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> 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)
, _strict_io (false)
, _custom_cfg (false)
, _maps_from_state (false)
+ , _latency_changed (false)
+ , _bypass_port (UINT32_MAX)
+ , _stat_reset (0)
{
/* 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 ());
}
}
}
PluginInsert::~PluginInsert ()
{
+ for (CtrlOutMap::const_iterator i = _control_outputs.begin(); i != _control_outputs.end(); ++i) {
+ boost::dynamic_pointer_cast<ReadOnlyControl>(i->second)->drop_references ();
+ }
}
void
{
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;
}
+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)
{
}
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) {
- n << "Sidechain " << Session::next_name_id ();
- } else {
+ if (n_audio == 0 && n_midi == 0) {
n << "TO BE RESET FROM XML";
+ } else if (owner()) {
+ n << "SC " << owner()->name() << "/" << name() << " " << Session::next_name_id ();
+ } else {
+ n << "tobeRenamed";
}
SideChain *sc = new SideChain (_session, n.str ());
_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;
return false;
}
_sidechain.reset ();
+ _sc_playback_latency = 0;
+ _sc_capture_latency = 0;
PluginConfigChanged (); /* EMIT SIGNAL */
return true;
}
+void
+PluginInsert::update_sidechain_name ()
+{
+ if (!_sidechain) {
+ return;
+ }
+
+ std::ostringstream n;
+
+ n << "SC ";
+ if (owner()) {
+ n << owner()->name() << "/";
+ }
+
+ n << name() << " " << Session::next_name_id ();
+
+ _sidechain->set_name (n.str());
+}
+
void
PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
{
= boost::dynamic_pointer_cast<AutomationControl>(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()));
}
}
{
#ifdef MIXBUS
if (is_channelstrip ()) {
- return _configured_out;
+ return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
}
#endif
return _plugins[0]->get_info()->n_outputs;
{
#ifdef MIXBUS
if (is_channelstrip ()) {
- return _configured_in;
+ return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
}
#endif
return _plugins[0]->get_info()->n_inputs;
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 ()) {
- return true;
+ return (pip->is_instrument ());
+}
+
+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;
}
- return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
+
+ if (!is_instrument ()) {
+ return false;
+ }
+ return true;
}
void
{
assert (!_plugins.empty());
+ boost::shared_ptr<Plugin> plugin = _plugins.front();
set<Evoral::Parameter> a = _plugins.front()->automatable ();
- for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
- if (i->type() == PluginAutomation) {
+ const uint32_t limit_automatables = Config->get_limit_n_automatables ();
- Evoral::Parameter param(*i);
+ for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
+ if (!plugin->parameter_is_control (i)) {
+ continue;
+ }
- ParameterDescriptor desc;
- _plugins.front()->get_parameter_descriptor(i->id(), desc);
+ ParameterDescriptor desc;
+ plugin->get_parameter_descriptor(i, desc);
- can_automate (param);
- boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
- boost::shared_ptr<AutomationControl> 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<AutomationList> list;
- if (Variant::type_is_numeric(desc.datatype)) {
- list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
- }
- add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
+ if (!plugin->parameter_is_input (i)) {
+ _control_outputs[i] = boost::shared_ptr<ReadOnlyControl> (new ReadOnlyControl (plugin, desc, i));
+ continue;
+ }
+ Evoral::Parameter param (PluginAutomation, 0, i);
+
+ const bool automatable = a.find(param) != a.end();
+
+ boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
+ boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
+ if (!automatable || (limit_automatables > 0 && i > limit_automatables)) {
+ 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<AutomationList> list;
+ if (Variant::type_is_numeric(desc.datatype)) {
+ list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
+ }
+ boost::shared_ptr<AutomationControl> 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<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:
*
return ret;
}
+void
+PluginInsert::automation_run (samplepos_t start, pframes_t nframes, bool only_active)
+{
+ // XXX does not work when rolling backwards
+ if (_loop_location && nframes > 0) {
+ const samplepos_t loop_start = _loop_location->start ();
+ const samplepos_t loop_end = _loop_location->end ();
+ const samplecnt_t looplen = loop_end - loop_start;
+
+ samplecnt_t remain = nframes;
+ samplepos_t start_pos = start;
+
+ while (remain > 0) {
+ if (start_pos >= loop_end) {
+ sampleoffset_t start_off = (start_pos - loop_start) % looplen;
+ start_pos = loop_start + start_off;
+ }
+ samplecnt_t move = std::min ((samplecnt_t)nframes, loop_end - start_pos);
+
+ Automatable::automation_run (start_pos, move, only_active);
+ remain -= move;
+ start_pos += move;
+ }
+ return;
+ }
+ Automatable::automation_run (start, nframes, only_active);
+}
+
+bool
+PluginInsert::find_next_event (double now, double end, Evoral::ControlEvent& next_event, bool only_active) const
+{
+ bool rv = Automatable::find_next_event (now, end, next_event, only_active);
+
+ if (_loop_location && now < end) {
+ if (rv) {
+ end = ceil (next_event.when);
+ }
+ const samplepos_t loop_end = _loop_location->end ();
+ assert (now < loop_end); // due to map_loop_range ()
+ if (end > loop_end) {
+ next_event.when = loop_end;
+ rv = true;
+ }
+ }
+ return rv;
+}
+
void
PluginInsert::activate ()
{
+ _timing_stats.reset ();
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
(*i)->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
PluginInsert::deactivate ()
{
+#ifdef MIXBUS
+ if (is_nonbypassable ()) {
+ return;
+ }
+#endif
+ _timing_stats.reset ();
Processor::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
}
void
-PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
+PluginInsert::enable (bool yn)
{
- // TODO: atomically copy maps & _no_inplace
- PinMappings in_map (_in_map);
- PinMappings out_map (_out_map);
- ChanMapping thru_map (_thru_map);
- if (_mapping_changed) { // ToDo use a counters, increment until match.
+ 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 ();
+}
+
+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<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, 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)
+{
+ if (_mapping_changed) { // ToDo use a counter, increment until match
_no_inplace = check_inplace ();
_mapping_changed = false;
}
+ // TODO: atomically copy maps & _no_inplace
+ PinMappings in_map (_in_map); // TODO Split case below overrides, use const& in_map
+ PinMappings const& out_map (_out_map);
+ ChanMapping const& thru_map (_thru_map);
if (_latency_changed) {
/* delaylines are configured with the max possible latency (as reported by the plugin)
continue;
}
bool valid;
- uint32_t first_idx = in_map[0].get (*t, 0, &valid);
+ uint32_t first_idx = in_map.p(0).get (*t, 0, &valid);
assert (valid && first_idx == 0); // check_inplace ensures this
/* copy the first stream's buffer contents to the others */
for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
- uint32_t idx = in_map[0].get (*t, i, &valid);
+ uint32_t idx = in_map.p(0).get (*t, i, &valid);
if (valid) {
assert (idx == 0);
bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
if (with_auto) {
+#if 0
uint32_t n = 0;
- for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
-
- boost::shared_ptr<AutomationControl> c
- = boost::dynamic_pointer_cast<AutomationControl>(li->second);
+ for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
- if (c->list() && c->automation_playback()) {
+ /* boost::dynamic_pointer_cast<> has significant overhead, since we know that
+ * all controls are AutomationControl and their lists - if any - are AutomationList,
+ * we can use static_cast<>. This yields a speedup of 2.8/4.6 over to the
+ * previous code (measuerd with VeeSeeVSTRack 10k parameters, optimized build) */
+ AutomationControl& c = static_cast<AutomationControl&> (*(li->second));
+ boost::shared_ptr<const Evoral::ControlList> clist (c.list());
+ if (clist && (static_cast<AutomationList const&> (*clist)).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
- * allowed to call
- * AutomationControl::set_value_unchecked(). We
- * know that the control is in
- * automation playback mode, so no
- * check on writable() is required
- * (which must be done in AutomationControl::set_value()
- *
- */
- c->set_value_unchecked(val);
+ c.set_value_unchecked(val);
+ }
+ }
+ }
+#else
+ boost::shared_ptr<ControlList> cl = _automated_controls.reader ();
+ for (ControlList::const_iterator ci = cl->begin(); ci != cl->end(); ++ci) {
+ AutomationControl& c = *(ci->get());
+ boost::shared_ptr<const Evoral::ControlList> clist (c.list());
+ /* we still need to check for Touch and Latch */
+ if (clist && (static_cast<AutomationList const&> (*clist)).automation_playback ()) {
+ bool valid;
+ const float val = c.list()->rt_safe_eval (start, valid);
+ if (valid) {
+ c.set_value_unchecked(val);
}
-
}
}
+#endif
}
- /* 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;
}
// 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 (ChanCount (DataType::AUDIO, input_streams().n_audio()));
- 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
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);
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
bool valid;
- uint32_t out_idx = out_map[pc].get (*t, out, &valid);
+ uint32_t out_idx = out_map.p(pc).get (*t, out, &valid);
if (valid) {
used_outputs.set (*t, out_idx, 1); // mark as used
}
for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
bool valid;
uint32_t in_idx = thru_map.get (*t, out, &valid);
+ uint32_t m = out + natural_input_streams ().get (*t);
if (valid) {
- uint32_t m = out + natural_input_streams ().get (*t);
_delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
used_outputs.set (*t, out, 1); // mark as used
+ } else {
+ used_outputs.get (*t, out, &valid);
+ if (valid) {
+ /* the plugin is expected to write here, but may not :(
+ * (e.g. drumgizmo w/o kit loaded)
+ */
+ inplace_bufs.get (*t, m).silence (nframes);
+ }
}
}
}
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
ARDOUR::ChanMapping i_in_map (natural_input_streams());
- ARDOUR::ChanMapping i_out_map (out_map[pc]);
+ ARDOUR::ChanMapping i_out_map (out_map.p(pc));
ARDOUR::ChanCount mapped;
/* map inputs sequentially */
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
bool valid;
- uint32_t in_idx = in_map[pc].get (*t, in, &valid);
+ uint32_t in_idx = in_map.p(pc).get (*t, in, &valid);
uint32_t m = mapped.get (*t);
if (valid) {
inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
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 ();
}
}
/* 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.p(pc), out_map.p(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) {
//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 (ChanCount (DataType::AUDIO, output_streams().n_audio()));
- 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,
&_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
+ */
+ if (_mapping_changed) {
+ _no_inplace = check_inplace ();
+ _mapping_changed = false;
+ }
+ // TODO: atomically copy maps & _no_inplace
+ ChanMapping const& in_map (no_sc_input_map ());
+ ChanMapping const& out_map (output_map ());
+
+ 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, true); // evaluate automation only
+
if (!active ()) {
+ // XXX delaybuffers need to be offset by nframes
return;
}
- ChanMapping in_map (natural_input_streams ());
- ChanMapping out_map (natural_output_streams ());
+ _delaybuffers.flush ();
- // TODO run sidechain (delaylines)
+ const ChanMapping in_map (natural_input_streams ());
+ const ChanMapping out_map (natural_output_streams ());
+ ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
+#ifdef MIXBUS
+ if (is_channelstrip ()) {
+ if (_configured_in.n_audio() > 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 ((*i)->get_info()->n_inputs, 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 (_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_sample, end_sample, speed, nframes, true);
+ }
- 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 (g_atomic_int_compare_and_exchange (&_stat_reset, 1, 0)) {
+ _timing_stats.reset ();
+ }
+
+ if (_pending_active) {
+#if defined MIXBUS && defined NDEBUG
+ if (!is_channelstrip ()) {
+ _timing_stats.start ();
}
+#else
+ _timing_stats.start ();
+#endif
+ /* run as normal if we are active or moving from inactive to active */
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);
- }
+#if defined MIXBUS && defined NDEBUG
+ if (!is_channelstrip ()) {
+ _timing_stats.update ();
}
+#else
+ _timing_stats.update ();
+#endif
- bufs.count().set_audio (out);
+ } else {
+ _timing_stats.reset ();
+ // 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, true); // evaluate automation only
+ _delaybuffers.flush ();
}
_active = _pending_active;
}
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()) {
+ /* map start back into loop-range, adjust end */
+ map_loop_range (start, end);
+
+ 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)) {
+ map_loop_range (start, end);
+
+ if (!find_next_event (start, end, next_event)) {
break;
}
}
/* 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);
}
}
#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));
}
}
+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
{
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
{
PluginInsert::is_channelstrip () const {
return _plugins.front()->is_channelstrip();
}
+bool
+PluginInsert::is_nonbypassable () const {
+ return _plugins.front()->is_nonbypassable ();
+}
#endif
bool
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 const& 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
}
ChanCount old_in;
ChanCount old_internal;
ChanCount old_out;
+ ChanCount old_pins;
- if (_configured) {
- old_in = _configured_in;
- old_internal = _configured_internal;
- old_out = _configured_out;
- }
+ old_pins = natural_input_streams();
+ old_in = _configured_in;
+ old_out = _configured_out;
+ old_internal = _configured_internal;
_configured_in = in;
_configured_internal = in;
#ifndef NDEBUG
if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
DEBUG_STR_DECL(a);
- DEBUG_STR_APPEND(a, string_compose ("Match '%1': ", name()));
+ DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
DEBUG_STR_APPEND(a, _match);
DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
}
break;
case Delegate:
{
- ChanCount dout (in); // hint
- if (_custom_cfg) {
+ 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 ());
}
if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
ChanCount useins;
- bool const r = _plugins.front()->can_support_io_configuration (in, 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 = in;
+ useins = din;
}
- DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("Delegate configuration: %1 %2 %3\n", name(), useins, dout));
+ DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
if (_plugins.front()->configure_io (useins, dout) == false) {
PluginIoReConfigure (); /* EMIT SIGNAL */
_configured = false;
return false;
}
+ if (!_custom_cfg) {
+ _custom_sinks = din;
+ }
}
break;
default:
break;
}
+ 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 () ? "==" : "!="
+ ));
+
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
- if (is_channelstrip ()) { _maps_from_state = false; }
+ if (is_channelstrip ()) {
+ /* fake channel map - for wire display */
+ _in_map.clear ();
+ _out_map.clear ();
+ _thru_map = ChanMapping ();
+ _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
+ _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
+ /* set "thru" map for in-place forward of audio */
+ for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
+ _thru_map.set (DataType::AUDIO, i, i);
+ }
+ /* and midi (after implicit 1st channel bypass) */
+ for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
+ _thru_map.set (DataType::MIDI, i, i);
+ }
+ } else
#endif
- if (_maps_from_state) {
- _maps_from_state = false;
+ if (_maps_from_state && old_in == in && old_out == out) {
mapping_changed = true;
sanitize_maps ();
} else {
/* generate a new mapping */
mapping_changed = reset_map (false);
}
+ _maps_from_state = false;
}
if (mapping_changed) {
*
* sidechain inputs add a constraint on the input:
* configured input + sidechain (=_configured_internal)
+ *
+ * NB. this also satisfies
+ * max (natural_input_streams(), natural_output_streams())
+ * which is needed for silence runs
*/
- _required_buffers =ChanCount::max (_configured_internal,
+ _required_buffers = ChanCount::max (_configured_internal,
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 */
}
- _delaybuffers.configure (_configured_out, _plugins.front()->max_latency ());
+ _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
_latency_changed = true;
- // we don't know the analysis window size, so we must work with the
- // current buffer size here. each request for data fills in these
- // 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);
+ /* we don't know the analysis window size, so we must work with the
+ * current buffer size here. each request for data fills in these
+ * buffers and the analyser makes sure it gets enough data for the
+ * analysis window. We also only analyze audio, so we can ignore
+ * MIDI buffers.
+ */
+ ChanCount cc_analysis_in (DataType::AUDIO, in.n_audio());
+ ChanCount cc_analysis_out (DataType::AUDIO, out.n_audio());
+
+ session().ensure_buffer_set (_signal_analysis_inputs, cc_analysis_in);
+ _signal_analysis_inputs.set_count (cc_analysis_in);
- session().ensure_buffer_set (_signal_analysis_outputs, out);
- //_signal_analysis_outputs.set_count (out);
+ session().ensure_buffer_set (_signal_analysis_outputs, cc_analysis_out);
+ _signal_analysis_outputs.set_count (cc_analysis_out);
// std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
Match rv = internal_can_support_io_configuration (in, out);
if (!_custom_cfg && _preset_out.n_audio () > 0) {
- DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("using output preset: %1 %2\n", name(), _preset_out));
+ DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
out.set (DataType::AUDIO, _preset_out.n_audio ());
}
return rv;
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);
}
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));
out = ChanCount::min (out, max_out);
- DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o instrument: %1\n", name()));
+ DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
return m;
}
f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
}
out = inx;
- DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o generator: %1\n", name()));
+ DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
return Match (Replicate, f, _strict_io);
}
break;
ChanCount ns_inputs = inputs - sidechain_input_pins ();
- DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
+ DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
if (info->reconfigurable_io()) {
ChanCount useins;
out = inx; // hint
if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
- bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
+ bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
if (!r) {
// 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);
}
out = in; // hint
if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
- bool const r = _plugins.front()->can_support_io_configuration (in, out);
+ bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
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);
}
ChanCount ns_inputs = inputs - sidechain_input_pins ();
if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
- DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
+ DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
midi_bypass.set (DataType::MIDI, 1);
}
if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
- DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
+ DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
in.set(DataType::MIDI, 0);
}
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);
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);
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());
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> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_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) {
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");
}
#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);
+ 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<LuaProc> 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"
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<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(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;
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) {
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) {
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.
}
}
+ /* 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;
}
}
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;
XMLNodeList kids = node.children ();
for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
+ 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);
}
if ((*i)->name() == X_("PresetOutput")) {
_preset_out = ChanCount(**i);
}
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;
}
// sidechain is a Processor (IO)
if ((*i)->name () == Processor::state_node_name) {
if (!_sidechain) {
- add_sidechain (0);
+ if (regenerate_xml_or_string_ids ()) {
+ add_sidechain_from_xml (**i, version);
+ } else {
+ add_sidechain (0);
+ }
+ }
+ if (!regenerate_xml_or_string_ids ()) {
+ _sidechain->set_state (**i, version);
+ } else {
+ update_sidechain_name ();
}
- _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)
{
}
XMLNodeList cnodes;
- XMLProperty *cprop;
XMLNodeConstIterator iter;
XMLNode *child;
- const char *port;
uint32_t port_id;
cnodes = (*niter)->children ("port");
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;
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;
}
}
+boost::shared_ptr<ReadOnlyControl>
+PluginInsert::control_output (uint32_t num) const
+{
+ CtrlOutMap::const_iterator i = _control_outputs.find (num);
+ if (i == _control_outputs.end ()) {
+ return boost::shared_ptr<ReadOnlyControl> ();
+ } else {
+ return (*i).second;
+ }
+}
string
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;
}
, _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.. */
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> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_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
: 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
}
_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;
{
boost::shared_ptr<Plugin> ret;
if (_impulseAnalysisPlugin.expired()) {
+ // LV2 in particular uses various _session params
+ // 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();
}
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;
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 ();
const ChanCount& nis (plugin->get_info()->n_inputs);
}
}
}
-#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::add_sidechain_from_xml (const XMLNode& node, int version)
+{
+ if (version < 3000) {
+ return;
+ }
+
+ XMLNodeList nlist = node.children();
+
+ if (nlist.size() == 0) {
+ return;
+ }
+
+ uint32_t audio = 0;
+ uint32_t midi = 0;
+
+ XMLNodeConstIterator it = nlist.front()->children().begin();
+ for ( ; it != nlist.front()->children().end(); ++ it) {
+ if ((*it)->name() == "Port") {
+ DataType type(DataType::NIL);
+ (*it)->get_property ("type", type);
+ if (type == DataType::AUDIO) {
+ ++audio;
+ } else if (type == DataType::MIDI) {
+ ++midi;
+ }
+ }
+ }
+
+ ChanCount in_cc = ChanCount();
+ in_cc.set (DataType::AUDIO, audio);
+ in_cc.set (DataType::MIDI, midi);
+
+ add_sidechain (audio, midi);
+}
+
+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 ()
{
}
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_sample() when rolling, assert > 0
+ ac->start_touch (session().audible_sample());
+ }
}
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_sample() when rolling, assert > 0
+ ac->stop_touch (session().audible_sample());
+ }
+}
+
+bool
+PluginInsert::provides_stats () const
+{
+#if defined MIXBUS && defined NDEBUG
+ if (is_channelstrip () || !display_to_user ()) {
+ return false;
+ }
+#endif
+ return true;
+}
+
+bool
+PluginInsert::get_stats (uint64_t& min, uint64_t& max, double& avg, double& dev) const
+{
+ /* TODO: consider taking a try/lock: Don't run concurrently with
+ * TimingStats::update, TimingStats::reset.
+ */
+ return _timing_stats.get_stats (min, max, avg, dev);
+}
+
+void
+PluginInsert::clear_stats ()
+{
+ g_atomic_int_set (&_stat_reset, 1);
}
std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
projects / ardour.git / blobdiff