X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fvst_plugin.cc;h=4183283bffe0f4acf158c6132fcf9a4c7317eebc;hb=b66726fdc12c91dc55be0cf18385aea06a300e15;hp=24020e835672f4c2d2de5029706082e600b887a7;hpb=23e7cf10191270d70357ccf0ed9294f020c7b7ab;p=ardour.git diff --git a/libs/ardour/vst_plugin.cc b/libs/ardour/vst_plugin.cc index 24020e8356..4183283bff 100644 --- a/libs/ardour/vst_plugin.cc +++ b/libs/ardour/vst_plugin.cc @@ -18,22 +18,23 @@ */ #include -#include +#include "pbd/gstdio_compat.h" #include #include +#include #include "pbd/floating.h" #include "pbd/locale_guard.h" +#include "ardour/vst_types.h" #include "ardour/vst_plugin.h" -#include "ardour/vestige/aeffectx.h" +#include "ardour/vestige/vestige.h" #include "ardour/session.h" -#include "ardour/vst_types.h" #include "ardour/filesystem_paths.h" #include "ardour/audio_buffer.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace PBD; @@ -44,8 +45,29 @@ VSTPlugin::VSTPlugin (AudioEngine& engine, Session& session, VSTHandle* handle) , _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 () @@ -54,17 +76,48 @@ 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 ("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 () { @@ -86,21 +139,66 @@ VSTPlugin::set_block_size (pframes_t nframes) return 0; } +bool +VSTPlugin::requires_fixed_sized_buffers () const +{ + /* This controls if Ardour will split the plugin's run() + * on automation events in order to pass sample-accurate automation + * via standard control-ports. + * + * When returning true Ardour will *not* sub-divide the process-cycle. + * Automation events that happen between cycle-start and cycle-end will be + * ignored (ctrl values are interpolated to cycle-start). + * + * Note: This does not guarantee a fixed block-size. + * e.g The process cycle may be split when looping, also + * the period-size may change any time: see set_block_size() + */ + if (get_info()->n_inputs.n_midi() > 0) { + /* we don't yet implement midi buffer offsets (for split cycles). + * Also session_vst callbacls uses _session.transport_sample() directly + * (for BBT) which is not offset for plugin cycle split. + */ + return true; + } + return false; +} + float -VSTPlugin::default_value (uint32_t) +VSTPlugin::default_value (uint32_t which) { - return 0; + return _parameter_defaults[which]; } 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 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)) { @@ -117,6 +215,14 @@ VSTPlugin::set_parameter (uint32_t which, float newval) } } +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 { @@ -149,8 +255,13 @@ int 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; } @@ -158,7 +269,7 @@ VSTPlugin::set_chunk (gchar const * data, bool single) void VSTPlugin::add_state (XMLNode* root) const { - LocaleGuard lg (X_("POSIX")); + LocaleGuard lg; if (_plugin->flags & 32 /* effFlagsProgramsChunks */) { @@ -174,6 +285,8 @@ VSTPlugin::add_state (XMLNode* root) const chunk_node->add_content (data); g_free (data); + chunk_node->set_property ("program", (int) _plugin->dispatcher (_plugin, effGetProgram, 0, 0, NULL, 0)); + root->add_child_nocopy (*chunk_node); } else { @@ -182,10 +295,8 @@ VSTPlugin::add_state (XMLNode* root) const 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); @@ -195,19 +306,19 @@ VSTPlugin::add_state (XMLNode* root) const 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; if ((child = find_named_node (node, X_("chunk"))) != 0) { + int pgm = -1; + if (child->get_property (X_("program"), pgm)) { + _plugin->dispatcher (_plugin, effSetProgram, 0, pgm, NULL, 0); + }; + XMLPropertyList::const_iterator i; XMLNodeList::const_iterator n; @@ -226,12 +337,11 @@ VSTPlugin::set_state (const XMLNode& node, int version) 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((*i)->value()); - _plugin->setParameter (_plugin, param, val); + _plugin->setParameter (_plugin, param, value); } ret = 0; @@ -243,15 +353,12 @@ VSTPlugin::set_state (const XMLNode& node, int version) return ret; } - int VSTPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const { VstParameterProperties prop; memset (&prop, 0, sizeof (VstParameterProperties)); - desc.min_unbound = false; - desc.max_unbound = false; prop.flags = 0; if (_plugin->dispatcher (_plugin, effGetParameterProperties, which, 0, &prop, 0)) { @@ -267,25 +374,22 @@ VSTPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) 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 { - - float range = desc.upper - desc.lower; - - desc.step = range / 100.0f; - desc.smallstep = desc.step / 2.0f; - desc.largestep = desc.step * 10.0f; + desc.smallstep = desc.step = range / 300.0f; + desc.largestep = range / 30.0f; } if (strlen(prop.label) == 0) { @@ -293,30 +397,35 @@ VSTPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) } 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; @@ -357,6 +466,7 @@ VSTPlugin::load_plugin_preset (PresetRecord r) sscanf (r.uri.c_str(), "VST:%d:%d", &id, &index); #endif _state->want_program = index; + LoadPresetProgram (); /* EMIT SIGNAL */ /* used for macvst */ return true; } @@ -375,11 +485,10 @@ VSTPlugin::load_user_preset (PresetRecord r) 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; } @@ -399,6 +508,7 @@ VSTPlugin::load_user_preset (PresetRecord r) _state->wanted_chunk = raw_data; _state->wanted_chunk_size = size; _state->want_chunk = 1; + LoadPresetProgram (); /* EMIT SIGNAL */ /* used for macvst */ return true; } } @@ -409,13 +519,17 @@ VSTPlugin::load_user_preset (PresetRecord r) 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; @@ -424,6 +538,8 @@ VSTPlugin::load_user_preset (PresetRecord r) return false; } +#include "sha1.c" + string VSTPlugin::do_save_preset (string name) { @@ -432,30 +548,48 @@ VSTPlugin::do_save_preset (string name) 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); - if (_plugin->flags & 32 /* effFlagsProgramsChunks */) { + 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); + } else { + p = new XMLNode (X_("Preset")); + } + + p->set_property (X_("uri"), uri); + p->set_property (X_("version"), version ()); + p->set_property (X_("label"), name); + p->set_property (X_("numParams"), parameter_count ()); + + if (_plugin->flags & 32) { + 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); - 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); } } @@ -489,7 +623,12 @@ VSTPlugin::do_remove_preset (string name) 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 */ @@ -503,14 +642,18 @@ VSTPlugin::describe_parameter (Evoral::Parameter param) 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 @@ -527,10 +670,24 @@ VSTPlugin::automatable () const 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 const& in_map, ChanMapping const& 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); @@ -549,7 +706,7 @@ VSTPlugin::connect_and_run (BufferSet& bufs, */ float** ins = (float**)alloca(_plugin->numInputs*sizeof(float*)); - float** outs = (float**)alloca(_plugin->numInputs*sizeof(float*)); + float** outs = (float**)alloca(_plugin->numOutputs*sizeof(float*)); int32_t i; @@ -569,14 +726,15 @@ VSTPlugin::connect_and_run (BufferSet& bufs, 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); + ? bufs.get_audio(index).data(offset) + : scratch_bufs.get_audio(0).data(offset); } if (bufs.count().n_midi() > 0) { VstEvents* v = 0; bool valid = false; const uint32_t buf_index_in = in_map.get(DataType::MIDI, 0, &valid); + /* TODO: apply offset to MIDI buffer and trim at nframes */ if (valid) { v = bufs.get_vst_midi (buf_index_in); } @@ -584,7 +742,8 @@ VSTPlugin::connect_and_run (BufferSet& bufs, 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); + /* TODO: apply offset to MIDI buffer and trim at nframes */ + _midi_out_buf->silence(nframes, offset); } else { _midi_out_buf = 0; } @@ -597,6 +756,7 @@ VSTPlugin::connect_and_run (BufferSet& bufs, _plugin->processReplacing (_plugin, &ins[0], &outs[0], nframes); _midi_out_buf = 0; + pthread_mutex_unlock (&_state->state_lock); return 0; } @@ -614,6 +774,9 @@ VSTPlugin::unique_id () const const char * VSTPlugin::name () const { + if (!_info->name.empty ()) { + return _info->name.c_str(); + } return _handle->name; } @@ -629,6 +792,12 @@ VSTPlugin::label () const return _handle->name; } +int32_t +VSTPlugin::version () const +{ + return _plugin->version; +} + uint32_t VSTPlugin::parameter_count () const { @@ -671,7 +840,8 @@ VSTPlugin::find_presets () 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 (), std::setw(4), std::setfill('0'), i), "", false); if (vst_version >= 2) { char buf[256]; @@ -694,14 +864,14 @@ VSTPlugin::find_presets () 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)); } } @@ -750,6 +920,34 @@ VSTPlugin::first_user_preset_index () const string VSTPlugin::presets_file () const { - return string_compose ("vst-%1", unique_id ()); + return string("vst-") + unique_id (); +} + + +VSTPluginInfo::VSTPluginInfo (VSTInfo* nfo) +{ + + char buf[32]; + snprintf (buf, sizeof (buf), "%d", nfo->UniqueID); + unique_id = buf; + + index = 0; + + name = nfo->name; + creator = nfo->creator; + n_inputs.set_audio (nfo->numInputs); + n_outputs.set_audio (nfo->numOutputs); + n_inputs.set_midi ((nfo->wantMidi & 1) ? 1 : 0); + n_outputs.set_midi ((nfo->wantMidi & 2) ? 1 : 0); + + _is_instrument = nfo->isInstrument; } +bool +VSTPluginInfo::is_instrument () const +{ + if (_is_instrument) { + return true; + } + return PluginInfo::is_instrument (); +}