*/
#include <glib.h>
-#include <glib/gstdio.h>
+#include "pbd/gstdio_compat.h"
#include <glibmm/fileutils.h>
#include <glibmm/miscutils.h>
+#include <glibmm/convert.h>
#include "pbd/floating.h"
#include "pbd/locale_guard.h"
-#include "pbd/pathscanner.h"
#include "ardour/vst_plugin.h"
#include "ardour/vestige/aeffectx.h"
#include "ardour/filesystem_paths.h"
#include "ardour/audio_buffer.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace PBD;
, _handle (handle)
, _state (0)
, _plugin (0)
+ , _pi (0)
+ , _num (0)
+ , _transport_sample (0)
+ , _transport_speed (0.f)
+ , _eff_bypassed (false)
{
-
+ memset (&_timeInfo, 0, sizeof(_timeInfo));
+}
+
+VSTPlugin::VSTPlugin (const VSTPlugin& other)
+ : Plugin (other)
+ , _handle (other._handle)
+ , _state (other._state)
+ , _plugin (other._plugin)
+ , _pi (other._pi)
+ , _num (other._num)
+ , _midi_out_buf (other._midi_out_buf)
+ , _transport_sample (0)
+ , _transport_speed (0.f)
+ , _parameter_defaults (other._parameter_defaults)
+ , _eff_bypassed (other._eff_bypassed)
+{
+ memset (&_timeInfo, 0, sizeof(_timeInfo));
}
VSTPlugin::~VSTPlugin ()
{
-
+
}
void
-VSTPlugin::set_plugin (AEffect* e)
+VSTPlugin::open_plugin ()
{
- _plugin = e;
- _plugin->user = this;
+ _plugin = _state->plugin;
+ assert (_plugin->ptr1 == this); // should have been set by {mac_vst|fst|lxvst}_instantiate
+ _plugin->ptr1 = this;
+ _state->plugin->dispatcher (_plugin, effOpen, 0, 0, 0, 0);
+ _state->vst_version = _plugin->dispatcher (_plugin, effGetVstVersion, 0, 0, 0, 0);
+}
+void
+VSTPlugin::init_plugin ()
+{
/* set rate and blocksize */
-
- _plugin->dispatcher (_plugin, effSetSampleRate, 0, 0, NULL, (float) _session.frame_rate());
+ _plugin->dispatcher (_plugin, effSetSampleRate, 0, 0, NULL, (float) _session.sample_rate());
_plugin->dispatcher (_plugin, effSetBlockSize, 0, _session.get_block_size(), NULL, 0.0f);
}
+
+uint32_t
+VSTPlugin::designated_bypass_port ()
+{
+ if (_plugin->dispatcher (_plugin, effCanDo, 0, 0, const_cast<char*> ("bypass"), 0.0f) != 0) {
+#ifdef ALLOW_VST_BYPASS_TO_FAIL // yet unused, see also plugin_insert.cc
+ return UINT32_MAX - 1; // emulate a port
+#else
+ /* check if plugin actually supports it,
+ * e.g. u-he Presswerk CanDo "bypass" but calling effSetBypass is a NO-OP.
+ * (presumably the plugin-author thinks hard-bypassing is a bad idea,
+ * particularly since the plugin itself provides a bypass-port)
+ */
+ intptr_t value = 0; // not bypassed
+ if (0 != _plugin->dispatcher (_plugin, 44 /*effSetBypass*/, 0, value, NULL, 0)) {
+ cerr << "Emulate VST Bypass Port for " << name() << endl; // XXX DEBUG
+ return UINT32_MAX - 1; // emulate a port
+ } else {
+ cerr << "Do *not* Emulate VST Bypass Port for " << name() << endl; // XXX DEBUG
+ }
+#endif
+ }
+ return UINT32_MAX;
+}
+
void
VSTPlugin::deactivate ()
{
_plugin->dispatcher (_plugin, effMainsChanged, 0, 1, NULL, 0.0f);
}
-int
+int
VSTPlugin::set_block_size (pframes_t nframes)
{
deactivate ();
}
float
-VSTPlugin::default_value (uint32_t)
+VSTPlugin::default_value (uint32_t which)
{
- return 0;
+ return _parameter_defaults[which];
}
-float
+float
VSTPlugin::get_parameter (uint32_t which) const
{
+ if (which == UINT32_MAX - 1) {
+ // ardour uses enable-semantics: 1: enabled, 0: bypassed
+ return _eff_bypassed ? 0.f : 1.f;
+ }
return _plugin->getParameter (_plugin, which);
}
-void
+void
VSTPlugin::set_parameter (uint32_t which, float newval)
{
+ if (which == UINT32_MAX - 1) {
+ // ardour uses enable-semantics: 1: enabled, 0: bypassed
+ intptr_t value = (newval <= 0.f) ? 1 : 0;
+ cerr << "effSetBypass " << value << endl; // XXX DEBUG
+ int rv = _plugin->dispatcher (_plugin, 44 /*effSetBypass*/, 0, value, NULL, 0);
+ if (0 != rv) {
+ _eff_bypassed = (value == 1);
+ } else {
+ cerr << "effSetBypass failed rv=" << rv << endl; // XXX DEBUG
+#ifdef ALLOW_VST_BYPASS_TO_FAIL // yet unused, see also vst_plugin.cc
+ // emit signal.. hard un/bypass from here?!
+#endif
+ }
+ return;
+ }
+
float oldval = get_parameter (which);
if (PBD::floateq (oldval, newval, 1)) {
}
_plugin->setParameter (_plugin, which, newval);
-
+
float curval = get_parameter (which);
if (!PBD::floateq (curval, oldval, 1)) {
}
}
+void
+VSTPlugin::parameter_changed_externally (uint32_t which, float value )
+{
+ ParameterChangedExternally (which, value); /* EMIT SIGNAL */
+ Plugin::set_parameter (which, value);
+}
+
+
uint32_t
VSTPlugin::nth_parameter (uint32_t n, bool& ok) const
{
VSTPlugin::set_chunk (gchar const * data, bool single)
{
gsize size = 0;
+ int r = 0;
guchar* raw_data = g_base64_decode (data, &size);
- int const r = _plugin->dispatcher (_plugin, 24 /* effSetChunk */, single ? 1 : 0, size, raw_data, 0);
+ {
+ pthread_mutex_lock (&_state->state_lock);
+ r = _plugin->dispatcher (_plugin, 24 /* effSetChunk */, single ? 1 : 0, size, raw_data, 0);
+ pthread_mutex_unlock (&_state->state_lock);
+ }
g_free (raw_data);
return r;
}
void
VSTPlugin::add_state (XMLNode* root) const
{
- LocaleGuard lg (X_("POSIX"));
+ LocaleGuard lg;
if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
for (int32_t n = 0; n < _plugin->numParams; ++n) {
char index[64];
- char val[32];
snprintf (index, sizeof (index), "param-%d", n);
- snprintf (val, sizeof (val), "%.12g", _plugin->getParameter (_plugin, n));
- parameters->add_property (index, val);
+ parameters->set_property (index, _plugin->getParameter (_plugin, n));
}
root->add_child_nocopy (*parameters);
int
VSTPlugin::set_state (const XMLNode& node, int version)
{
- LocaleGuard lg (X_("POSIX"));
+ LocaleGuard lg;
int ret = -1;
- if (node.name() != state_node_name()) {
- error << _("Bad node sent to VSTPlugin::set_state") << endmsg;
- return 0;
- }
-
#ifndef NO_PLUGIN_STATE
XMLNode* child;
for (n = child->children ().begin (); n != child->children ().end (); ++n) {
if ((*n)->is_content ()) {
/* XXX: this may be dubious for the same reasons that we delay
- execution of load_preset.
- */
+ execution of load_preset.
+ */
ret = set_chunk ((*n)->content().c_str(), false);
}
}
for (i = child->properties().begin(); i != child->properties().end(); ++i) {
int32_t param;
- float val;
sscanf ((*i)->name().c_str(), "param-%d", ¶m);
- sscanf ((*i)->value().c_str(), "%f", &val);
+ float value = string_to<float>((*i)->value());
- _plugin->setParameter (_plugin, param, val);
+ _plugin->setParameter (_plugin, param, value);
}
ret = 0;
return ret;
}
-
int
VSTPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
{
VstParameterProperties prop;
- desc.min_unbound = false;
- desc.max_unbound = false;
+ memset (&prop, 0, sizeof (VstParameterProperties));
prop.flags = 0;
if (_plugin->dispatcher (_plugin, effGetParameterProperties, which, 0, &prop, 0)) {
/* i have yet to find or hear of a VST plugin that uses this */
+ /* RG: faust2vsti does use this :) */
if (prop.flags & kVstParameterUsesIntegerMinMax) {
desc.lower = prop.minInteger;
desc.upper = 1.0;
}
- if (prop.flags & kVstParameterUsesIntStep) {
+ const float range = desc.upper - desc.lower;
+ if (prop.flags & kVstParameterUsesIntStep && prop.stepInteger < range) {
desc.step = prop.stepInteger;
desc.smallstep = prop.stepInteger;
desc.largestep = prop.stepInteger;
-
- } else if (prop.flags & kVstParameterUsesFloatStep) {
-
+ desc.integer_step = true;
+ desc.rangesteps = 1 + ceilf (range / desc.step);
+ } else if (prop.flags & kVstParameterUsesFloatStep && prop.stepFloat < range) {
desc.step = prop.stepFloat;
desc.smallstep = prop.smallStepFloat;
desc.largestep = prop.largeStepFloat;
-
+ desc.rangesteps = 1 + ceilf (range / desc.step);
} else {
+ desc.smallstep = desc.step = range / 300.0f;
+ desc.largestep = range / 30.0f;
+ }
- float range = desc.upper - desc.lower;
-
- desc.step = range / 100.0f;
- desc.smallstep = desc.step / 2.0f;
- desc.largestep = desc.step * 10.0f;
+ if (strlen(prop.label) == 0) {
+ _plugin->dispatcher (_plugin, effGetParamName, which, 0, prop.label, 0);
}
desc.toggled = prop.flags & kVstParameterIsSwitch;
- desc.logarithmic = false;
- desc.sr_dependent = false;
- desc.label = prop.label;
+ desc.label = Glib::locale_to_utf8 (prop.label);
} else {
/* old style */
- char label[64];
+ char label[VestigeMaxLabelLen];
/* some VST plugins expect this buffer to be zero-filled */
memset (label, 0, sizeof (label));
_plugin->dispatcher (_plugin, effGetParamName, which, 0, label, 0);
-
- desc.label = label;
- desc.integer_step = false;
+
+ desc.label = Glib::locale_to_utf8 (label);
desc.lower = 0.0f;
desc.upper = 1.0f;
- desc.step = 0.01f;
- desc.smallstep = 0.005f;
- desc.largestep = 0.1f;
- desc.toggled = false;
- desc.logarithmic = false;
- desc.sr_dependent = false;
+ desc.smallstep = desc.step = 1.f / 300.f;
+ desc.largestep = 1.f / 30.f;
+ }
+
+ /* TODO we should really call
+ * desc.update_steps ()
+ * instead of manually assigning steps. Yet, VST prop is (again)
+ * the odd one out compared to other plugin formats.
+ */
+
+ if (_parameter_defaults.find (which) == _parameter_defaults.end ()) {
+ _parameter_defaults[which] = get_parameter (which);
+ } else {
+ desc.normal = _parameter_defaults[which];
}
return 0;
return s;
}
-bool
+bool
VSTPlugin::load_plugin_preset (PresetRecord r)
{
/* This is a plugin-provided preset.
#ifndef NDEBUG
int const p = sscanf (r.uri.c_str(), "VST:%d:%d", &id, &index);
assert (p == 2);
-#else
+#else
sscanf (r.uri.c_str(), "VST:%d:%d", &id, &index);
#endif
-
_state->want_program = index;
+ LoadPresetProgram (); /* EMIT SIGNAL */ /* used for macvst */
return true;
}
-bool
+bool
VSTPlugin::load_user_preset (PresetRecord r)
{
/* This is a user preset; we load it, and this code also knows about the
XMLNode* root = t->root ();
for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
- XMLProperty* label = (*i)->property (X_("label"));
+ std::string label;
+ (*i)->get_property (X_("label"), label);
- assert (label);
-
- if (label->value() != r.label) {
+ if (label != r.label) {
continue;
}
_state->wanted_chunk = raw_data;
_state->wanted_chunk_size = size;
_state->want_chunk = 1;
+ LoadPresetProgram (); /* EMIT SIGNAL */ /* used for macvst */
return true;
}
}
return false;
} else {
-
+
for (XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
if ((*j)->name() == X_("Parameter")) {
- XMLProperty* index = (*j)->property (X_("index"));
- XMLProperty* value = (*j)->property (X_("value"));
+ uint32_t index;
+ float value;
- assert (index);
- assert (value);
+ if (!(*j)->get_property (X_("index"), index) ||
+ !(*j)->get_property (X_("value"), value)) {
+ // flag error and continue?
+ assert (false);
+ }
- set_parameter (atoi (index->value().c_str()), atof (value->value().c_str ()));
+ set_parameter (index, value);
+ PresetPortSetValue (index, value); /* EMIT SIGNAL */
}
}
return true;
return false;
}
-string
+#include "sha1.c"
+
+string
VSTPlugin::do_save_preset (string name)
{
boost::shared_ptr<XMLTree> t (presets_tree ());
return "";
}
+ // prevent dups -- just in case
+ t->root()->remove_nodes_and_delete (X_("label"), name);
+
XMLNode* p = 0;
- /* XXX: use of _presets.size() + 1 for the unique ID here is dubious at best */
- string const uri = string_compose (X_("VST:%1:%2"), unique_id (), _presets.size() + 1);
+
+ char tmp[32];
+ snprintf (tmp, 31, "%ld", _presets.size() + 1);
+ tmp[31] = 0;
+
+ char hash[41];
+ Sha1Digest s;
+ sha1_init (&s);
+ sha1_write (&s, (const uint8_t *) name.c_str(), name.size ());
+ sha1_write (&s, (const uint8_t *) tmp, strlen(tmp));
+ sha1_result_hash (&s, hash);
+
+ string const uri = string_compose (X_("VST:%1:x%2"), unique_id (), hash);
if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
p = new XMLNode (X_("ChunkPreset"));
- p->add_property (X_("uri"), uri);
- p->add_property (X_("label"), name);
+ p->set_property (X_("uri"), uri);
+ p->set_property (X_("label"), name);
gchar* data = get_chunk (true);
p->add_content (string (data));
g_free (data);
} else {
p = new XMLNode (X_("Preset"));
- p->add_property (X_("uri"), uri);
- p->add_property (X_("label"), name);
+ p->set_property (X_("uri"), uri);
+ p->set_property (X_("label"), name);
for (uint32_t i = 0; i < parameter_count(); ++i) {
if (parameter_is_input (i)) {
XMLNode* c = new XMLNode (X_("Parameter"));
- c->add_property (X_("index"), string_compose ("%1", i));
- c->add_property (X_("value"), string_compose ("%1", get_parameter (i)));
+ c->set_property (X_("index"), i);
+ c->set_property (X_("value"), get_parameter (i));
p->add_child_nocopy (*c);
}
}
return uri;
}
-void
+void
VSTPlugin::do_remove_preset (string name)
{
boost::shared_ptr<XMLTree> t (presets_tree ());
t->write (f);
}
-string
+string
VSTPlugin::describe_parameter (Evoral::Parameter param)
{
- char name[64];
+ char name[VestigeMaxLabelLen];
+ if (param.id() == UINT32_MAX - 1) {
+ strcpy (name, _("Plugin Enable"));
+ return name;
+ }
+
memset (name, 0, sizeof (name));
/* some VST plugins expect this buffer to be zero-filled */
return name;
}
-framecnt_t
+samplecnt_t
VSTPlugin::signal_latency () const
{
if (_user_latency) {
return _user_latency;
}
+#if ( defined(__x86_64__) || defined(_M_X64) )
+ return *((int32_t *) (((char *) &_plugin->flags) + 24)); /* initialDelay */
+#else
return *((int32_t *) (((char *) &_plugin->flags) + 12)); /* initialDelay */
+#endif
}
-set<Evoral::Parameter>
+set<Evoral::Parameter>
VSTPlugin::automatable () const
{
set<Evoral::Parameter> ret;
int
VSTPlugin::connect_and_run (BufferSet& bufs,
- ChanMapping in_map, ChanMapping out_map,
- pframes_t nframes, framecnt_t offset)
-{
- Plugin::connect_and_run (bufs, in_map, out_map, nframes, offset);
+ samplepos_t start, samplepos_t end, double speed,
+ ChanMapping in_map, ChanMapping out_map,
+ pframes_t nframes, samplecnt_t offset)
+{
+ Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
+
+ if (pthread_mutex_trylock (&_state->state_lock)) {
+ /* by convention 'effSetChunk' should not be called while processing
+ * http://www.reaper.fm/sdk/vst/vst_ext.php
+ *
+ * All VSTs don't use in-place, PluginInsert::connect_and_run()
+ * does clear output buffers, so we can just return.
+ */
+ return 0;
+ }
+
+ _transport_sample = start;
+ _transport_speed = speed;
+
+ ChanCount bufs_count;
+ bufs_count.set(DataType::AUDIO, 1);
+ bufs_count.set(DataType::MIDI, 1);
+ _midi_out_buf = 0;
+
+ BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
+ BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
+
+ /* VC++ doesn't support the C99 extension that allows
+
+ typeName foo[variableDefiningSize];
+
+ Use alloca instead of dynamic array (rather than std::vector which
+ allocs on the heap) because this is realtime code.
+ */
- // VC++ doesn't support this C99 extension. Use alloca instead of dynamic array (rather than std::vector which allocs on the heap)
float** ins = (float**)alloca(_plugin->numInputs*sizeof(float*));
- float** outs = (float**)alloca(_plugin->numInputs*sizeof(float*));
- int32_t i;
+ float** outs = (float**)alloca(_plugin->numOutputs*sizeof(float*));
- const uint32_t nbufs = bufs.count().n_audio();
+ int32_t i;
- int in_index = 0;
+ uint32_t in_index = 0;
for (i = 0; i < (int32_t) _plugin->numInputs; ++i) {
- ins[i] = bufs.get_audio(min((uint32_t) in_index, nbufs - 1)).data() + offset;
- in_index++;
+ uint32_t index;
+ bool valid = false;
+ index = in_map.get(DataType::AUDIO, in_index++, &valid);
+ ins[i] = (valid)
+ ? bufs.get_audio(index).data(offset)
+ : silent_bufs.get_audio(0).data(offset);
}
- int out_index = 0;
+ uint32_t out_index = 0;
for (i = 0; i < (int32_t) _plugin->numOutputs; ++i) {
- outs[i] = bufs.get_audio(min((uint32_t) out_index, nbufs - 1)).data() + offset;
- out_index++;
+ uint32_t index;
+ bool valid = false;
+ index = out_map.get(DataType::AUDIO, out_index++, &valid);
+ outs[i] = (valid)
+ ? bufs.get_audio(index).data(offset)
+ : scratch_bufs.get_audio(0).data(offset);
}
if (bufs.count().n_midi() > 0) {
- VstEvents* v = bufs.get_vst_midi (0);
- _plugin->dispatcher (_plugin, effProcessEvents, 0, 0, v, 0);
+ VstEvents* v = 0;
+ bool valid = false;
+ const uint32_t buf_index_in = in_map.get(DataType::MIDI, 0, &valid);
+ if (valid) {
+ v = bufs.get_vst_midi (buf_index_in);
+ }
+ valid = false;
+ const uint32_t buf_index_out = out_map.get(DataType::MIDI, 0, &valid);
+ if (valid) {
+ _midi_out_buf = &bufs.get_midi(buf_index_out);
+ _midi_out_buf->silence(0, 0);
+ } else {
+ _midi_out_buf = 0;
+ }
+ if (v) {
+ _plugin->dispatcher (_plugin, effProcessEvents, 0, 0, v, 0);
+ }
}
/* we already know it can support processReplacing */
_plugin->processReplacing (_plugin, &ins[0], &outs[0], nframes);
+ _midi_out_buf = 0;
+ pthread_mutex_unlock (&_state->state_lock);
return 0;
}
-string
+string
VSTPlugin::unique_id () const
{
char buf[32];
snprintf (buf, sizeof (buf), "%d", _plugin->uniqueID);
-
+
return string (buf);
}
-const char *
+const char *
VSTPlugin::name () const
{
+ if (!_info->name.empty ()) {
+ return _info->name.c_str();
+ }
return _handle->name;
}
-const char *
+const char *
VSTPlugin::maker () const
{
return _info->creator.c_str();
}
-const char *
+const char *
VSTPlugin::label () const
{
return _handle->name;
}
-uint32_t
+uint32_t
VSTPlugin::parameter_count () const
{
return _plugin->numParams;
}
-bool
+bool
VSTPlugin::has_editor () const
{
return _plugin->flags & effFlagsHasEditor;
}
-void
+void
VSTPlugin::print_parameter (uint32_t param, char *buf, uint32_t /*len*/) const
{
char *first_nonws;
int const vst_version = _plugin->dispatcher (_plugin, effGetVstVersion, 0, 0, NULL, 0);
for (int i = 0; i < _plugin->numPrograms; ++i) {
- PresetRecord r (string_compose (X_("VST:%1:%2"), unique_id (), i), "", -1, false);
+ PresetRecord r (string_compose (X_("VST:%1:%2"), unique_id (), i), "", false);
if (vst_version >= 2) {
char buf[256];
if (t) {
XMLNode* root = t->root ();
for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
+ std::string uri;
+ std::string label;
- XMLProperty* uri = (*i)->property (X_("uri"));
- XMLProperty* label = (*i)->property (X_("label"));
-
- assert (uri);
- assert (label);
+ if (!(*i)->get_property (X_("uri"), uri) || !(*i)->get_property (X_("label"), label)) {
+ assert(false);
+ }
- PresetRecord r (uri->value(), label->value(), -1, true);
+ PresetRecord r (uri, label, true);
_presets.insert (make_pair (r.uri, r));
}
}
string
VSTPlugin::presets_file () const
{
- return string_compose ("vst-%1", unique_id ());
+ return string("vst-") + unique_id ();
}
projects / ardour.git / blobdiff