#include <VSTWrapper.h>

Inheritance diagram for VSTWrapper:

Collaboration diagram for VSTWrapper:

Classes
struct	ParameterInfo

struct	ResourceHandle

Public Types
using	ParameterVisitor = std::function< bool(const ParameterInfo &pi) >

using	ModuleHandle = std::unique_ptr< wxDynamicLibrary >

using	BundleHandle = CF_ptr< CFBundleRef >

Public Member Functions
	VSTWrapper (const PluginPath &path)

	~VSTWrapper ()

intptr_t	callDispatcher (int opcode, int index, intptr_t value, void *ptr, float opt) override

intptr_t	constCallDispatcher (int opcode, int index, intptr_t value, void *ptr, float opt) const

float	callGetParameter (int index) const

void	callSetChunk (bool isPgm, int len, void *buf)

void	callSetChunk (bool isPgm, int len, void buf, VstPatchChunkInfo info) const

int	GetString (wxString &outstr, int opcode, int index=0) const

wxString	GetString (int opcode, int index=0) const

void	ForEachParameter (ParameterVisitor visitor) const

bool	FetchSettings (VSTSettings &vst3Settings, bool doFetch=true) const

bool	StoreSettings (const VSTSettings &vst3settings) const

VstPatchChunkInfo	GetChunkInfo () const

bool	IsCompatible (const VstPatchChunkInfo &) const

bool	LoadXML (const wxFileName &fn)

bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs) override

void	HandleXMLEndTag (const std::string_view &tag) override

void	HandleXMLContent (const std::string_view &content) override

XMLTagHandler *	HandleXMLChild (const std::string_view &tag) override

void	SetString (int opcode, const wxString &str, int index=0)

ComponentInterfaceSymbol	GetSymbol () const

void	callSetParameter (int index, float value) const

void	SaveXML (const wxFileName &fn) const

bool	LoadFXB (const wxFileName &fn)

bool	LoadFXP (const wxFileName &fn)

bool	LoadFXProgram (unsigned char **bptr, ssize_t &len, int index, bool dryrun)

void	callSetProgram (int index)

void	SaveFXB (const wxFileName &fn) const

void	SaveFXP (const wxFileName &fn) const

void	SaveFXProgram (wxMemoryBuffer &buf, int index) const

bool	Load ()

void	Unload ()

void	ResetModuleAndHandle ()

VstTimeInfo *	GetTimeInfo ()

float	GetSampleRate ()

int	GetProcessLevel ()

virtual void	SetBufferDelay (int samples)

std::unique_ptr< EffectInstance::Message >	MakeMessageFS (const VSTSettings &settings) const

Public Member Functions inherited from VSTLink
virtual	~VSTLink ()

virtual intptr_t	callDispatcher (int opcode, int index, intptr_t value, void *ptr, float opt)=0

Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()

virtual	~XMLTagHandler ()

virtual bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs)=0

virtual void	HandleXMLEndTag (const std::string_view &WXUNUSED(tag))

virtual void	HandleXMLContent (const std::string_view &WXUNUSED(content))

virtual XMLTagHandler *	HandleXMLChild (const std::string_view &tag)=0

void	ReadXMLEndTag (const char *tag)

void	ReadXMLContent (const char *s, int len)

XMLTagHandler *	ReadXMLChild (const char *tag)

Public Member Functions inherited from VSTUIWrapper
virtual void	Idle ()

virtual void	NeedIdle ()

virtual void	SizeWindow (int w, int h)

virtual void	Automate (int index, float value)

virtual void	Flush ()

Static Public Member Functions
static VSTSettings &	GetSettings (EffectSettings &settings)

static const VSTSettings &	GetSettings (const EffectSettings &settings)

static intptr_t	AudioMaster (AEffect effect, int32_t opcode, int32_t index, intptr_t value, void ptr, float opt)

Public Attributes
AEffect *	mAEffect = nullptr

std::thread::id	mMainThreadId

std::recursive_mutex	mDispatcherLock

int	mVstVersion

wxString	mName

bool	mInSet

bool	mInChunk

wxString	mChunk

long	mXMLVersion

VstPatchChunkInfo	mXMLInfo

intptr_t	mCurrentEffectID {}

PluginPath	mPath

ModuleHandle	mModule {}

wxString	mVendor

wxString	mDescription

int	mVersion

bool	mInteractive { false }

unsigned	mAudioIns { 0 }

unsigned	mAudioOuts { 0 }

int	mMidiIns { 0 }

int	mMidiOuts { 0 }

bool	mAutomatable

BundleHandle	mBundleRef

ResourceHandle	mResource

VstTimeInfo	mTimeInfo

int	mBufferDelay { 0 }

int	mProcessLevel { 1 }

bool	mGui { false }

Detailed Description

Definition at line 100 of file VSTWrapper.h.

Member Typedef Documentation

◆ BundleHandle

using VSTWrapper::BundleHandle = CF_ptr<CFBundleRef>

Definition at line 233 of file VSTWrapper.h.

◆ ModuleHandle

using VSTWrapper::ModuleHandle = std::unique_ptr<wxDynamicLibrary>

Definition at line 207 of file VSTWrapper.h.

◆ ParameterVisitor

using VSTWrapper::ParameterVisitor = std::function< bool(const ParameterInfo& pi) >

Returns: true continue visiting; false stop visiting

Definition at line 152 of file VSTWrapper.h.

Constructor & Destructor Documentation

◆ VSTWrapper()

VSTWrapper::VSTWrapper ( const PluginPath & path )

inlineexplicit

Definition at line 117 of file VSTWrapper.h.

      : mPath(path)
      , mMainThreadId{ std::this_thread::get_id() }
   {}

◆ ~VSTWrapper()

VSTWrapper::~VSTWrapper ( )

Definition at line 597 of file VSTWrapper.cpp.

{
   Unload();
   ResetModuleAndHandle();
}

References ResetModuleAndHandle(), and Unload().

Here is the call graph for this function:

Member Function Documentation

◆ AudioMaster()

intptr_t VSTWrapper::AudioMaster	(	AEffect *	effect,
		int32_t	opcode,
		int32_t	index,
		intptr_t	value,
		void *	ptr,
		float	opt
	)

static

Definition at line 59 of file VSTWrapper.cpp.

{
   VSTWrapper* vst = (effect ? static_cast<VSTWrapper*>(effect->ptr2) : nullptr);
 
   // Handles operations during initialization...before VSTEffect has had a
   // chance to set its instance pointer.
   switch (opcode)
   {
      case audioMasterVersion:
         return (intptr_t) 2400;
 
      case audioMasterCurrentId:
         return vst->mCurrentEffectID;
 
      case audioMasterGetVendorString:
         strcpy((char *) ptr, "Audacity Team");    // Do not translate, max 64 + 1 for null terminator
         return 1;
 
      case audioMasterGetProductString:
         strcpy((char *) ptr, "Audacity");         // Do not translate, max 64 + 1 for null terminator
         return 1;
 
      case audioMasterGetVendorVersion:
         return (intptr_t) (AUDACITY_VERSION << 24 |
                            AUDACITY_RELEASE << 16 |
                            AUDACITY_REVISION << 8 |
                            AUDACITY_MODLEVEL);
 
      // Some (older) effects depend on an effIdle call when requested.  An
      // example is the Antress Modern plugins which uses the call to update
      // the editors display when the program (preset) changes.
      case audioMasterNeedIdle:
         if (vst)
         {
            vst->NeedIdle();
            return 1;
         }
         return 0;
 
      // We would normally get this if the effect editor is dipslayed and something "major"
      // has changed (like a program change) instead of multiple automation calls.
      // Since we don't do anything with the parameters while the editor is displayed,
      // there's no need for us to do anything.
      case audioMasterUpdateDisplay:
         if (vst)
         {
            return 1;
         }
         return 0;
 
      // Return the current time info.
      case audioMasterGetTime:
         if (vst)
         {
            return (intptr_t) vst->GetTimeInfo();
         }
         return 0;
 
      // Inputs, outputs, or initial delay has changed...all we care about is initial delay.
      case audioMasterIOChanged:
         if (vst)
         {
            vst->SetBufferDelay(effect->initialDelay);
            return 1;
         }
         return 0;
 
      case audioMasterGetSampleRate:
         if (vst)
         {
            return (intptr_t) vst->GetSampleRate();
         }
         return 0;
 
      case audioMasterIdle:
         if (vst)
            vst->Idle();
         return 1;
 
      case audioMasterGetCurrentProcessLevel:
         if (vst)
         {
            return vst->GetProcessLevel();
         }
         return 0;
 
      case audioMasterGetLanguage:
         return kVstLangEnglish;
 
      // We always replace, never accumulate
      case audioMasterWillReplaceOrAccumulate:
         return 1;
 
      // Resize the window to accommodate the effect size
      case audioMasterSizeWindow:
         if (vst)
         {
            vst->SizeWindow(index, value);
         }
         return 1;
 
      case audioMasterCanDo:
      {
         char *s = (char *) ptr;
         if (strcmp(s, "acceptIOChanges") == 0 ||
            strcmp(s, "sendVstTimeInfo") == 0 ||
            strcmp(s, "startStopProcess") == 0 ||
            strcmp(s, "shellCategory") == 0 ||
            strcmp(s, "sizeWindow") == 0)
         {
            return 1;
         }
 
#if defined(VST_DEBUG)
#if defined(__WXMSW__)
         wxLogDebug(wxT("VST canDo: %s"), wxString::FromAscii((char *)ptr));
#else
         wxPrintf(wxT("VST canDo: %s\n"), wxString::FromAscii((char *)ptr));
#endif
#endif
 
         return 0;
      }
 
      case audioMasterBeginEdit:
      case audioMasterEndEdit:
         return 0;
 
      case audioMasterAutomate:
         if (vst)
         {
            vst->Automate(index, opt);
         }
         return 0;
 
      // We're always connected (sort of)
      case audioMasterPinConnected:
 
      // We don't do MIDI yet
      case audioMasterWantMidi:
      case audioMasterProcessEvents:
 
         // Don't need to see any messages about these
         return 0;
   }
 
#if defined(VST_DEBUG)
#if defined(__WXMSW__)
   wxLogDebug(wxT("vst: %p opcode: %d index: %d value: %p ptr: %p opt: %f user: %p"),
              effect, (int) opcode, (int) index, (void *) value, ptr, opt, vst);
#else
   wxPrintf(wxT("vst: %p opcode: %d index: %d value: %p ptr: %p opt: %f user: %p\n"),
            effect, (int) opcode, (int) index, (void *) value, ptr, opt, vst);
#endif
#endif
 
   return 0;
}

References audioMasterAutomate, audioMasterBeginEdit, audioMasterCanDo, audioMasterCurrentId, audioMasterEndEdit, audioMasterGetCurrentProcessLevel, audioMasterGetLanguage, audioMasterGetProductString, audioMasterGetSampleRate, audioMasterGetTime, audioMasterGetVendorString, audioMasterGetVendorVersion, audioMasterIdle, audioMasterIOChanged, audioMasterNeedIdle, audioMasterPinConnected, audioMasterProcessEvents, audioMasterSizeWindow, audioMasterUpdateDisplay, audioMasterVersion, audioMasterWantMidi, audioMasterWillReplaceOrAccumulate, VSTUIWrapper::Automate(), GetProcessLevel(), GetSampleRate(), GetTimeInfo(), VSTUIWrapper::Idle(), AEffect::initialDelay, kVstLangEnglish, mCurrentEffectID, VSTUIWrapper::NeedIdle(), AEffect::ptr2, SetBufferDelay(), VSTUIWrapper::SizeWindow(), and wxT().

Referenced by Load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callDispatcher()

intptr_t VSTWrapper::callDispatcher	(	int	opcode,
		int	index,
		intptr_t	value,
		void *	ptr,
		float	opt
	)

overridevirtual

Implements VSTLink.

Definition at line 682 of file VSTWrapper.cpp.

{
   // Needed since we might be in the dispatcher when the timer pops
   std::lock_guard guard(mDispatcherLock);
 
   return mAEffect->dispatcher(mAEffect, opcode, index, value, ptr, opt);
}

References AEffect::dispatcher, mAEffect, and mDispatcherLock.

Referenced by callSetProgram(), constCallDispatcher(), VSTInstance::DoProcessInitialize(), VSTEffectBase::GetEffectIDs(), HandleXMLEndTag(), HandleXMLTag(), Load(), LoadFXB(), LoadFXProgram(), LoadXML(), VSTEditor::OnTimer(), VSTInstance::PowerOff(), VSTInstance::PowerOn(), SetString(), and Unload().

Here is the caller graph for this function:

◆ callGetParameter()

float VSTWrapper::callGetParameter ( int index ) const

Definition at line 699 of file VSTWrapper.cpp.

{
   return mAEffect->getParameter(mAEffect, index);
}

References AEffect::getParameter, and mAEffect.

Referenced by FetchSettings(), SaveFXProgram(), and SaveXML().

Here is the caller graph for this function:

◆ callSetChunk() [1/2]

void VSTWrapper::callSetChunk	(	bool	isPgm,
		int	len,
		void *	buf
	)

Definition at line 721 of file VSTWrapper.cpp.

{
   VstPatchChunkInfo info;
 
   memset(&info, 0, sizeof(info));
   info.version = 1;
   info.pluginUniqueID = mAEffect->uniqueID;
   info.pluginVersion = mAEffect->version;
   info.numElements = isPgm ? mAEffect->numParams : mAEffect->numPrograms;
 
   callSetChunk(isPgm, len, buf, &info);
}

References callSetChunk(), mAEffect, VstPatchChunkInfo::numElements, AEffect::numParams, AEffect::numPrograms, VstPatchChunkInfo::pluginUniqueID, VstPatchChunkInfo::pluginVersion, AEffect::uniqueID, AEffect::version, and VstPatchChunkInfo::version.

Referenced by VSTInstance::ApplyChunk(), callSetChunk(), HandleXMLEndTag(), LoadFXB(), LoadFXProgram(), VSTEffectBase::LoadUserPreset(), and StoreSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callSetChunk() [2/2]

void VSTWrapper::callSetChunk	(	bool	isPgm,
		int	len,
		void *	buf,
		VstPatchChunkInfo *	info
	)		const

Definition at line 734 of file VSTWrapper.cpp.

{
   if (isPgm)
   {
      // Ask the effect if this is an acceptable program
      if (constCallDispatcher(effBeginLoadProgram, 0, 0, info, 0.0) == -1)
      {
         return;
      }
   }
   else
   {
      // Ask the effect if this is an acceptable bank
      if (constCallDispatcher(effBeginLoadBank, 0, 0, info, 0.0) == -1)
      {
         return;
      }
   }
 
   constCallDispatcher(effBeginSetProgram, 0, 0, NULL, 0.0);
   constCallDispatcher(effSetChunk, isPgm ? 1 : 0, len, buf, 0.0);
   constCallDispatcher(effEndSetProgram, 0, 0, NULL, 0.0);
}

References constCallDispatcher(), effBeginLoadBank, effBeginLoadProgram, effBeginSetProgram, effEndSetProgram, and effSetChunk.

Here is the call graph for this function:

◆ callSetParameter()

void VSTWrapper::callSetParameter	(	int	index,
		float	value
	)		const

Definition at line 704 of file VSTWrapper.cpp.

{
   if (mVstVersion == 0 || constCallDispatcher(effCanBeAutomated, 0, index, NULL, 0.0))
   {
      mAEffect->setParameter(mAEffect, index, value);
   }
}

References constCallDispatcher(), effCanBeAutomated, mAEffect, mVstVersion, and AEffect::setParameter.

Referenced by HandleXMLTag(), LoadFXProgram(), and VSTInstance::RealtimeProcessStart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callSetProgram()

void VSTWrapper::callSetProgram ( int index )

Definition at line 712 of file VSTWrapper.cpp.

{
   callDispatcher(effBeginSetProgram, 0, 0, NULL, 0.0);
 
   callDispatcher(effSetProgram, 0, index, NULL, 0.0);
 
   callDispatcher(effEndSetProgram, 0, 0, NULL, 0.0);
}

References callDispatcher(), effBeginSetProgram, effEndSetProgram, and effSetProgram.

Referenced by VSTEffectBase::DoLoadFactoryPreset(), Load(), and LoadFXB().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ constCallDispatcher()

intptr_t VSTWrapper::constCallDispatcher	(	int	opcode,
		int	index,
		intptr_t	value,
		void *	ptr,
		float	opt
	)		const

Definition at line 691 of file VSTWrapper.cpp.

{
   // Assume we are passed a read-only dispatcher function code
   return const_cast<VSTWrapper*>(this)
      ->callDispatcher(opcode, index, value, ptr, opt);
}

References callDispatcher().

Referenced by callSetChunk(), callSetParameter(), FetchSettings(), GetString(), SaveFXB(), SaveFXP(), SaveFXProgram(), VSTEffectBase::SaveUserPreset(), SaveXML(), and StoreSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchSettings()

bool VSTWrapper::FetchSettings	(	VSTSettings &	vst3Settings,
		bool	doFetch = `true`
	)		const

Definition at line 1714 of file VSTWrapper.cpp.

{
   // Get the fallback ID-value parameters
   ForEachParameter
   (
      [&](const ParameterInfo& pi)
      {
         if (doFetch)
         {
            float val = callGetParameter(pi.mID);
            vstSettings.mParamsMap[pi.mName] = val;
         }
         else
         {
            vstSettings.mParamsMap[pi.mName] = std::nullopt;
         }
         return true;
      }
   );
 
   // These are here to be checked against for compatibility later
   vstSettings.mVersion   = mAEffect->version;
   vstSettings.mUniqueID  = mAEffect->uniqueID;
   vstSettings.mNumParams = mAEffect->numParams;
 
   // Get the chunk (if supported)
   vstSettings.mChunk.resize(0);
 
   if (mAEffect->flags & effFlagsProgramChunks)
   {
      void* chunk = nullptr;
      int clen = (int)constCallDispatcher(effGetChunk, 1, 0, &chunk, 0.0);
      if (clen > 0 && chunk) {
         vstSettings.mChunk.resize(clen);
         memcpy(vstSettings.mChunk.data(), chunk, clen);
      }
 
      if (!doFetch)
      {
         // Don't keep the contents, but keep a sufficiently allocated string,
         // with some extra space in case chunk length might vary
         auto size = vstSettings.mChunk.size();
         vstSettings.mChunk.resize(0);
         vstSettings.mChunk.reserve(2 * size);
      }
   }
 
   return true;
}

References callGetParameter(), constCallDispatcher(), effFlagsProgramChunks, effGetChunk, AEffect::flags, ForEachParameter(), mAEffect, VSTSettings::mChunk, VSTSettings::mNumParams, VSTSettings::mParamsMap, VSTSettings::mUniqueID, VSTSettings::mVersion, AEffect::numParams, MIR::anonymous_namespace{MirUtils.cpp}::pi, size, AEffect::uniqueID, and AEffect::version.

Referenced by VSTEditor::FetchSettingsFromInstance(), VSTEffect::ImportPresetsNC(), VSTEffectBase::LoadFactoryPreset(), VSTEffectBase::LoadUserPreset(), VSTInstance::MakeMessage(), and VSTEffectBase::MakeSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ForEachParameter()

void VSTWrapper::ForEachParameter ( ParameterVisitor visitor ) const

Definition at line 1688 of file VSTWrapper.cpp.

{
   for (int i = 0; i < mAEffect->numParams; i++)
   {
      wxString name = GetString(effGetParamName, i);
      if (name.empty())
      {
         name.Printf(wxT("parm_%d"), i);
      }
      else
         /* Easy fix for now for issue 3854, but this should be reconsidered
          There is the possibility that two parameter names might collide
          after normalizing.  A question is whether the normalizing was ever
          really needed for saving in a wxConfigFile.  Maybe not.  But then
          redefinition of the keys stored in the file may introduce versioning
          difficulties if there is an attempt to fix this in future Audacity.
          */
         name = CommandParameters::NormalizeName(name);
 
      ParameterInfo pi{ i, name };
 
      if (!visitor(pi))
         break;
   }
}

References effGetParamName, GetString(), mAEffect, name, CommandParameters::NormalizeName(), AEffect::numParams, MIR::anonymous_namespace{MirUtils.cpp}::pi, and wxT().

Referenced by FetchSettings(), MakeMessageFS(), VSTEditor::NotifyParameterChanged(), StoreSettings(), and VSTEditor::VSTEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetChunkInfo()

VstPatchChunkInfo VSTWrapper::GetChunkInfo ( ) const

Definition at line 603 of file VSTWrapper.cpp.

{
   VstPatchChunkInfo info = { 1, mAEffect->uniqueID, mAEffect->version, mAEffect->numParams, "" };
   return info;
}

References mAEffect, AEffect::numParams, AEffect::uniqueID, and AEffect::version.

Referenced by VSTEffectBase::LoadUserPreset().

Here is the caller graph for this function:

◆ GetProcessLevel()

int VSTWrapper::GetProcessLevel ( )

Definition at line 638 of file VSTWrapper.cpp.

{
   return mProcessLevel;
}

References mProcessLevel.

Referenced by AudioMaster().

Here is the caller graph for this function:

◆ GetSampleRate()

float VSTWrapper::GetSampleRate ( )

Definition at line 633 of file VSTWrapper.cpp.

{
   return mTimeInfo.sampleRate;
}

References mTimeInfo, and VstTimeInfo::sampleRate.

Referenced by AudioMaster().

Here is the caller graph for this function:

◆ GetSettings() [1/2]

static const VSTSettings & VSTWrapper::GetSettings ( const EffectSettings & settings )

inlinestatic

Definition at line 110 of file VSTWrapper.h.

   {
      auto pSettings = settings.cast<VSTSettings>();
      assert(pSettings);
      return *pSettings;
   }

References settings().

Here is the call graph for this function:

◆ GetSettings() [2/2]

static VSTSettings & VSTWrapper::GetSettings ( EffectSettings & settings )

inlinestatic

Definition at line 103 of file VSTWrapper.h.

   {
      auto pSettings = settings.cast<VSTSettings>();
      assert(pSettings);
      return *pSettings;
   }

References settings().

Referenced by VSTEffect::ExportPresets(), VSTEditor::FetchSettingsFromInstance(), VSTEffect::ImportPresetsNC(), VSTEffectBase::LoadFactoryPreset(), VSTEffectBase::LoadSettings(), VSTEffectBase::LoadUserPreset(), VSTEditor::NotifyParameterChanged(), VSTInstance::ProcessInitialize(), VSTEffectBase::SaveSettings(), VSTEffectBase::SaveUserPreset(), VSTEditor::StoreSettingsToInstance(), and VSTEditor::VSTEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetString() [1/2]

wxString VSTWrapper::GetString	(	int	opcode,
		int	index = `0`
	)		const

Definition at line 665 of file VSTWrapper.cpp.

{
   wxString str;
 
   GetString(str, opcode, index);
 
   return str;
}

References GetString(), and str.

Here is the call graph for this function:

◆ GetString() [2/2]

int VSTWrapper::GetString	(	wxString &	outstr,
		int	opcode,
		int	index = `0`
	)		const

Definition at line 651 of file VSTWrapper.cpp.

{
   char buf[256];
 
   memset(buf, 0, sizeof(buf));
 
   // Assume we are passed a read-only dispatcher function code
   constCallDispatcher(opcode, index, 0, buf, 0.0);
 
   outstr = wxString::FromUTF8(buf);
 
   return 0;
}

References constCallDispatcher().

Referenced by VSTEditor::BuildPlain(), ForEachParameter(), VSTEffectBase::GetFactoryPresets(), GetString(), Load(), VSTEditor::RefreshParameters(), and SaveXML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSymbol()

ComponentInterfaceSymbol VSTWrapper::GetSymbol ( ) const

Definition at line 1813 of file VSTWrapper.cpp.

{
   return mName;
}

References mName.

Referenced by VSTEffectBase::GetSymbol(), HandleXMLTag(), and SaveXML().

Here is the caller graph for this function:

◆ GetTimeInfo()

VstTimeInfo * VSTWrapper::GetTimeInfo ( )

Definition at line 627 of file VSTWrapper.cpp.

{
   mTimeInfo.nanoSeconds = wxGetUTCTimeMillis().ToDouble();
   return &mTimeInfo;
}

References mTimeInfo, and VstTimeInfo::nanoSeconds.

Referenced by AudioMaster().

Here is the caller graph for this function:

◆ HandleXMLChild()

XMLTagHandler * VSTWrapper::HandleXMLChild ( const std::string_view & tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 1658 of file VSTWrapper.cpp.

{
   if (tag == "vstprogrampersistence")
   {
      return this;
   }
 
   if (tag == "effect")
   {
      return this;
   }
 
   if (tag == "program")
   {
      return this;
   }
 
   if (tag == "param")
   {
      return this;
   }
 
   if (tag == "chunk")
   {
      return this;
   }
 
   return NULL;
}

◆ HandleXMLContent()

void VSTWrapper::HandleXMLContent ( const std::string_view & content )

override

Definition at line 1650 of file VSTWrapper.cpp.

{
   if (mInChunk)
   {
      mChunk += wxString(std::string(content)).Trim(true).Trim(false);
   }
}

References mChunk, and mInChunk.

◆ HandleXMLEndTag()

void VSTWrapper::HandleXMLEndTag ( const std::string_view & tag )

override

Definition at line 1620 of file VSTWrapper.cpp.

{
   if (tag == "chunk")
   {
      if (mChunk.length())
      {
         ArrayOf<char> buf{ mChunk.length() / 4 * 3 };
 
         int len = Base64::Decode(mChunk, buf.get());
         if (len)
         {
            callSetChunk(true, len, buf.get(), &mXMLInfo);
         }
 
         mChunk.clear();
      }
      mInChunk = false;
   }
 
   if (tag == "program")
   {
      if (mInSet)
      {
         callDispatcher(effEndSetProgram, 0, 0, NULL, 0.0);
 
         mInSet = false;
      }
   }
}

References callDispatcher(), callSetChunk(), Base64::Decode(), effEndSetProgram, mChunk, mInChunk, mInSet, and mXMLInfo.

Here is the call graph for this function:

◆ HandleXMLTag()

bool VSTWrapper::HandleXMLTag	(	const std::string_view &	tag,
		const AttributesList &	attrs
	)

overridevirtual

Implements XMLTagHandler.

Definition at line 1413 of file VSTWrapper.cpp.

{
   if (tag == "vstprogrampersistence")
   {
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         if (attr == "version")
         {
            if (!value.TryGet(mXMLVersion))
            {
               return false;
            }
 
            if (mXMLVersion < 1 || mXMLVersion > 2)
            {
               return false;
            }
         }
         else
         {
            return false;
         }
      }
 
      return true;
   }
 
   if (tag == "effect")
   {
      memset(&mXMLInfo, 0, sizeof(mXMLInfo));
      mXMLInfo.version = 1;
      mXMLInfo.pluginUniqueID = mAEffect->uniqueID;
      mXMLInfo.pluginVersion = mAEffect->version;
      mXMLInfo.numElements = mAEffect->numParams;
 
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         if (attr == "name")
         {
            wxString strValue = value.ToWString();
 
            if (strValue != GetSymbol().Internal())
            {
               using namespace BasicUI;
               auto msg = XO("This parameter file was saved from %s. Continue?")
                  .Format( strValue );
               auto result = ShowMessageBox(
                  msg,
                  MessageBoxOptions{}
                     .Caption(XO("Confirm"))
                     .ButtonStyle(Button::YesNo));
               if (result == MessageBoxResult::No)
                  return false;
            }
         }
         else if (attr == "version")
         {
            long version;
            if (!value.TryGet(version))
            {
               return false;
            }
 
            mXMLInfo.pluginVersion = (int) version;
         }
         else if (mXMLVersion > 1 && attr == "uniqueID")
         {
            long uniqueID;
            if (!value.TryGet(uniqueID))
            {
               return false;
            }
 
            mXMLInfo.pluginUniqueID = (int) uniqueID;
         }
         else if (mXMLVersion > 1 && attr == "numParams")
         {
            long numParams;
            if (!value.TryGet(numParams))
            {
               return false;
            }
 
            mXMLInfo.numElements = (int) numParams;
         }
         else
         {
            return false;
         }
      }
 
      return true;
   }
 
   if (tag == "program")
   {
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         if (attr == "name")
         {
            const wxString strValue = value.ToWString();
 
            if (strValue.length() > 24)
            {
               return false;
            }
 
            int ndx = 0; //mProgram->GetCurrentSelection();
            if (ndx == wxNOT_FOUND)
            {
               ndx = 0;
            }
 
            SetString(effSetProgramName, strValue, ndx);
         }
         else
         {
            return false;
         }
      }
 
      mInChunk = false;
 
      if (callDispatcher(effBeginLoadProgram, 0, 0, &mXMLInfo, 0.0) == -1)
      {
         return false;
      }
 
      callDispatcher(effBeginSetProgram, 0, 0, NULL, 0.0);
 
      mInSet = true;
 
      return true;
   }
 
   if (tag == "param")
   {
      long ndx = -1;
      double val = -1.0;
 
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         if (attr == "index")
         {
            if (!value.TryGet(ndx))
            {
               return false;
            }
 
            if (ndx < 0 || ndx >= mAEffect->numParams)
            {
               // Could be a different version of the effect...probably should
               // tell the user
               return false;
            }
         }
         // "name" attribute is ignored for params
         /* else if (attr == "name")
         {
 
            // Nothing to do with it for now
         }*/
         else if (attr == "value")
         {
            if (!value.TryGet(val))
            {
               return false;
            }
 
            if (val < 0.0 || val > 1.0)
            {
               return false;
            }
         }
      }
 
      if (ndx == -1 || val == -1.0)
      {
         return false;
      }
 
      callSetParameter(ndx, val);
 
      return true;
   }
 
   if (tag == "chunk")
   {
      mInChunk = true;
      return true;
   }
 
   return false;
}

References callDispatcher(), callSetParameter(), BasicUI::MessageBoxOptions::Caption(), effBeginLoadProgram, effBeginSetProgram, effSetProgramName, GetSymbol(), Internal, mAEffect, mInChunk, mInSet, mXMLInfo, mXMLVersion, VstPatchChunkInfo::numElements, AEffect::numParams, VstPatchChunkInfo::pluginUniqueID, VstPatchChunkInfo::pluginVersion, SetString(), BasicUI::ShowMessageBox(), AEffect::uniqueID, AEffect::version, VstPatchChunkInfo::version, and XO().

Here is the call graph for this function:

◆ IsCompatible()

bool VSTWrapper::IsCompatible ( const VstPatchChunkInfo & info ) const

Definition at line 609 of file VSTWrapper.cpp.

{
   return  (info.pluginUniqueID == mAEffect->uniqueID) &&
           (info.pluginVersion  == mAEffect->version) &&
           (info.numElements    == mAEffect->numParams);
}

References mAEffect, VstPatchChunkInfo::numElements, AEffect::numParams, VstPatchChunkInfo::pluginUniqueID, VstPatchChunkInfo::pluginVersion, AEffect::uniqueID, and AEffect::version.

Referenced by VSTEffectBase::LoadUserPreset().

Here is the caller graph for this function:

◆ Load()

bool VSTWrapper::Load ( )

Definition at line 307 of file VSTWrapper.cpp.

{
   vstPluginMain pluginMain;
   bool success = false;
 
   long effectID = 0;
   wxString realPath = mPath.BeforeFirst(wxT(';'));
   mPath.AfterFirst(wxT(';')).ToLong(&effectID);
   mCurrentEffectID = (intptr_t) effectID;
 
   mModule = NULL;
   mAEffect = NULL;
 
#if defined(__WXMAC__)
   // Start clean
   mBundleRef.reset();
 
   mResource = ResourceHandle{};
 
   // Convert the path to a CFSTring
   wxCFStringRef path(realPath);
 
   // Create the bundle using the URL
   BundleHandle bundleRef{ CFBundleCreate(kCFAllocatorDefault,
      // Convert the path to a URL
      CF_ptr<CFURLRef>{
         CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
            path, kCFURLPOSIXPathStyle, true)
      }.get()
   )};
 
   // Bail if the bundle wasn't created
   if (!bundleRef)
      return false;
 
 
   // Convert back to path
   UInt8 exePath[PLATFORM_MAX_PATH];
   Boolean good = CFURLGetFileSystemRepresentation(
      // Retrieve a reference to the executable
      CF_ptr<CFURLRef>{ CFBundleCopyExecutableURL(bundleRef.get()) }.get(),
      true, exePath, sizeof(exePath)
   );
 
   // Bail if we couldn't resolve the executable path
   if (good == FALSE)
      return false;
 
   // Attempt to open it
   mModule.reset((char*)dlopen((char *) exePath, RTLD_NOW | RTLD_LOCAL));
   if (!mModule)
      return false;
 
   // Try to locate the NEW plugin entry point
   pluginMain = (vstPluginMain) dlsym(mModule.get(), "VSTPluginMain");
 
   // If not found, try finding the old entry point
   if (pluginMain == NULL)
   {
      pluginMain = (vstPluginMain) dlsym(mModule.get(), "main_macho");
   }
 
   // Must not be a VST plugin
   if (pluginMain == NULL)
   {
      mModule.reset();
      return false;
   }
 
   // Need to keep the bundle reference around so we can map the
   // resources.
   mBundleRef = std::move(bundleRef);
 
   // Open the resource map ... some plugins (like GRM Tools) need this.
   mResource = ResourceHandle{
      mBundleRef.get(), CFBundleOpenBundleResourceMap(mBundleRef.get())
   };
 
#elif defined(__WXMSW__)
 
   {
      wxLogNull nolog;
 
      // Try to load the library
      auto lib = std::make_unique<wxDynamicLibrary>(realPath);
      if (!lib)
         return false;
 
      // Bail if it wasn't successful
      if (!lib->IsLoaded())
         return false;
 
      // Try to find the entry point, while suppressing error messages
      pluginMain = (vstPluginMain) lib->GetSymbol(wxT("VSTPluginMain"));
      if (pluginMain == NULL)
      {
         pluginMain = (vstPluginMain) lib->GetSymbol(wxT("main"));
         if (pluginMain == NULL)
            return false;
      }
 
      // Save the library reference
      mModule = std::move(lib);
   }
 
#else
 
   // Attempt to load it
   //
   // Spent a few days trying to figure out why some VSTs where running okay and
   // others were hit or miss.  The cause was that we export all of Audacity's
   // symbols and some of the loaded libraries were picking up Audacity's and
   // not their own.
   //
   // So far, I've only seen this issue on Linux, but we might just be getting
   // lucky on the Mac and Windows.  The sooner we stop exporting everything
   // the better.
   //
   // To get around the problem, I just added the RTLD_DEEPBIND flag to the load
   // and that "basically" puts Audacity last when the loader needs to resolve
   // symbols.
   //
   // Once we define a proper external API, the flags can be removed.
#ifndef RTLD_DEEPBIND
#define RTLD_DEEPBIND 0
#endif
   ModuleHandle lib {
      (char*) dlopen((const char *)wxString(realPath).ToUTF8(),
                     RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND)
   };
   if (!lib)
   {
      return false;
   }
 
   // Try to find the entry point, while suppressing error messages
   pluginMain = (vstPluginMain) dlsym(lib.get(), "VSTPluginMain");
   if (pluginMain == NULL)
   {
      pluginMain = (vstPluginMain) dlsym(lib.get(), "main");
      if (pluginMain == NULL)
         return false;
   }
 
   // Save the library reference
   mModule = std::move(lib);
 
#endif
 
   // Initialize the plugin
   try
   {
      mAEffect = pluginMain(VSTWrapper::AudioMaster);
   }
   catch (...)
   {
      wxLogMessage(wxT("VST plugin initialization failed\n"));
      mAEffect = NULL;
   }
 
   // Was it successful?
   if (mAEffect)
   {
      mGui = (mAEffect->flags & effFlagsHasEditor);
 
      // Must use the GUI editor if parameters aren't provided
      if (mAEffect->numParams == 0)
      {
         mGui = true;
      }
 
      // Save a reference to ourselves
      //
      // Note:  Some hosts use "user" and some use "ptr2/resvd2".  It might
      //        be worthwhile to check if user is NULL before using it and
      //        then falling back to "ptr2/resvd2".
      mAEffect->ptr2 = static_cast<VSTWrapper*>(this);
 
      // Give the plugin an initial sample rate and blocksize
      callDispatcher(effSetSampleRate, 0, 0, NULL, 48000.0);
      callDispatcher(effSetBlockSize, 0, 512, NULL, 0);
 
      // Ask the plugin to identify itself...might be needed for older plugins
      callDispatcher(effIdentify, 0, 0, NULL, 0);
 
      // Open the plugin
      callDispatcher(effOpen, 0, 0, NULL, 0.0);
 
      // Get the VST version the plugin understands
      mVstVersion = callDispatcher(effGetVstVersion, 0, 0, NULL, 0);
 
      // Set it again in case plugin ignored it before the effOpen
      callDispatcher(effSetSampleRate, 0, 0, NULL, 48000.0);
      callDispatcher(effSetBlockSize, 0, 512, NULL, 0);
 
      // Ensure that it looks like a plugin and can deal with ProcessReplacing
      // calls.  Also exclude synths for now.
      if (mAEffect->magic == kEffectMagic &&
         !(mAEffect->flags & effFlagsIsSynth) &&
         mAEffect->flags & effFlagsCanReplacing)
      {
         if (mVstVersion >= 2)
         {
            mName = GetString(effGetEffectName);
            if (mName.length() == 0)
            {
               mName = GetString(effGetProductString);
            }
         }
         if (mName.length() == 0)
         {
            mName = wxFileName{realPath}.GetName();
         }
 
         if (mVstVersion >= 2)
         {
            mVendor = GetString(effGetVendorString);
            mVersion = wxINT32_SWAP_ON_LE(callDispatcher(effGetVendorVersion, 0, 0, NULL, 0));
         }
         if (mVersion == 0)
         {
            mVersion = wxINT32_SWAP_ON_LE(mAEffect->version);
         }
 
         if (mAEffect->flags & effFlagsHasEditor || mAEffect->numParams != 0)
         {
            mInteractive = true;
         }
 
         mAudioIns = mAEffect->numInputs;
         mAudioOuts = mAEffect->numOutputs;
 
         // Check to see if parameters can be automated.  This isn't a guarantee
         // since it could be that the effect simply doesn't support the opcode.
         mAutomatable = false;
         for (int i = 0; i < mAEffect->numParams; i++)
         {
            if (callDispatcher(effCanBeAutomated, 0, i, NULL, 0.0))
            {
               mAutomatable = true;
               break;
            }
         }
 
         // Make sure we start out with a valid program selection
         // I've found one plugin (SoundHack +morphfilter) that will
         // crash Audacity when saving the initial default parameters
         // with this.
         callSetProgram(0);
 
         // Pretty confident that we're good to go
         success = true;
      }
   }
 
   if (!success)
   {
      Unload();
      ResetModuleAndHandle();
   }
 
   return success;
}

References AudioMaster(), callDispatcher(), callSetProgram(), effCanBeAutomated, effFlagsCanReplacing, effFlagsHasEditor, effFlagsIsSynth, effGetEffectName, effGetProductString, effGetVendorString, effGetVendorVersion, effGetVstVersion, effIdentify, effOpen, effSetBlockSize, effSetSampleRate, AEffect::flags, GetString(), kEffectMagic, mAEffect, AEffect::magic, mAudioIns, mAudioOuts, mAutomatable, mBundleRef, mCurrentEffectID, mGui, mInteractive, mModule, mName, mPath, mResource, mVendor, mVersion, mVstVersion, AEffect::numInputs, AEffect::numOutputs, AEffect::numParams, PLATFORM_MAX_PATH, AEffect::ptr2, ResetModuleAndHandle(), Unload(), AEffect::version, and wxT().

Referenced by VSTEffectsModule::DiscoverPluginsAtPath(), VSTEffectBase::InitializePlugin(), and VSTInstance::VSTInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadFXB()

bool VSTWrapper::LoadFXB ( const wxFileName & fn )

Definition at line 758 of file VSTWrapper.cpp.

{
   bool ret = false;
 
   // Try to open the file...will be closed automatically when method returns
   wxFFile f(fn.GetFullPath(), wxT("rb"));
   if (!f.IsOpened())
   {
      return false;
   }
 
   // Allocate memory for the contents
   ArrayOf<unsigned char> data{ size_t(f.Length()) };
   if (!data)
   {
      using namespace BasicUI;
      ShowMessageBox(
         XO("Unable to allocate memory when loading presets file."),
         MessageBoxOptions{}
            .Caption(XO("Error Loading VST Presets")));
      return false;
   }
   unsigned char *bptr = data.get();
 
   do
   {
      // Read in the whole file
      ssize_t len = f.Read((void *) bptr, f.Length());
      if (f.Error())
      {
         using namespace BasicUI;
         ShowMessageBox(
            XO("Unable to read presets file."),
            MessageBoxOptions{}
               .Caption(XO("Error Loading VST Presets")));
         break;
      }
 
      // Most references to the data are via an "int" array
      int32_t *iptr = (int32_t *) bptr;
 
      // Verify that we have at least enough for the header
      if (len < 156)
      {
         break;
      }
 
      // Verify that we probably have an FX file
      if (wxINT32_SWAP_ON_LE(iptr[0]) != CCONST('C', 'c', 'n', 'K'))
      {
         break;
      }
 
      // Ignore the size...sometimes it's there, other times it's zero
 
      // Get the version and verify
      int version = wxINT32_SWAP_ON_LE(iptr[3]);
      if (version != 1 && version != 2)
      {
         break;
      }
 
      VstPatchChunkInfo info =
      {
         1,
         wxINT32_SWAP_ON_LE(iptr[4]),
         wxINT32_SWAP_ON_LE(iptr[5]),
         wxINT32_SWAP_ON_LE(iptr[6]),
         ""
      };
 
      // Ensure this program looks to belong to the current plugin
      if ((info.pluginUniqueID != mAEffect->uniqueID) &&
          (info.pluginVersion != mAEffect->version) &&
          (info.numElements != mAEffect->numPrograms))
      {
         break;
      }
 
      // Get the number of programs
      int numProgs = info.numElements;
 
      // Get the current program index
      int curProg = 0;
      if (version >= 2)
      {
         curProg = wxINT32_SWAP_ON_LE(iptr[7]);
         if (curProg < 0 || curProg >= numProgs)
         {
            break;
         }
      }
 
      // Is it a bank of programs?
      if (wxINT32_SWAP_ON_LE(iptr[2]) == CCONST('F', 'x', 'B', 'k'))
      {
         // Drop the header
         bptr += 156;
         len -= 156;
 
         unsigned char *tempPtr = bptr;
         ssize_t tempLen = len;
 
         // Validate all of the programs
         for (int i = 0; i < numProgs; i++)
         {
            if (!LoadFXProgram(&tempPtr, tempLen, i, true))
            {
               break;
            }
         }
 
         // Ask the effect if this is an acceptable bank
         if (callDispatcher(effBeginLoadBank, 0, 0, &info, 0.0) == -1)
         {
            return false;
         }
 
         // Start loading the individual programs
         for (int i = 0; i < numProgs; i++)
         {
            ret = LoadFXProgram(&bptr, len, i, false);
         }
      }
      // Or maybe a bank chunk?
      else if (wxINT32_SWAP_ON_LE(iptr[2]) == CCONST('F', 'B', 'C', 'h'))
      {
         // Can't load programs chunks if the plugin doesn't support it
         if (!(mAEffect->flags & effFlagsProgramChunks))
         {
            break;
         }
 
         // Verify that we have enough to grab the chunk size
         if (len < 160)
         {
            break;
         }
 
         // Get the chunk size
         int size = wxINT32_SWAP_ON_LE(iptr[39]);
 
         // We finally know the full length of the program
         int proglen = 160 + size;
 
         // Verify that we have enough for the entire program
         if (len < proglen)
         {
            break;
         }
 
         // Set the entire bank in one shot
         callSetChunk(false, size, &iptr[40], &info);
 
         // Success
         ret = true;
      }
      // Unrecognizable type
      else
      {
         break;
      }
 
      // Set the active program
      if (ret && version >= 2)
      {
         callSetProgram(curProg);
      }
   } while (false);
 
   return ret;
}

References callDispatcher(), callSetChunk(), callSetProgram(), BasicUI::MessageBoxOptions::Caption(), CCONST, effBeginLoadBank, effFlagsProgramChunks, AEffect::flags, fn, LoadFXProgram(), mAEffect, VstPatchChunkInfo::numElements, AEffect::numPrograms, VstPatchChunkInfo::pluginUniqueID, VstPatchChunkInfo::pluginVersion, BasicUI::ShowMessageBox(), size, AEffect::uniqueID, AEffect::version, wxT(), and XO().

Referenced by VSTEffect::ImportPresetsNC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadFXP()

bool VSTWrapper::LoadFXP ( const wxFileName & fn )

Definition at line 931 of file VSTWrapper.cpp.

{
   bool ret = false;
 
   // Try to open the file...will be closed automatically when method returns
   wxFFile f(fn.GetFullPath(), wxT("rb"));
   if (!f.IsOpened())
   {
      return false;
   }
 
   // Allocate memory for the contents
   ArrayOf<unsigned char> data{ size_t(f.Length()) };
   if (!data)
   {
      using namespace BasicUI;
      ShowMessageBox(
         XO("Unable to allocate memory when loading presets file."),
         MessageBoxOptions{}
            .Caption(XO("Error Loading VST Presets")));
      return false;
   }
   unsigned char *bptr = data.get();
 
   do
   {
      // Read in the whole file
      ssize_t len = f.Read((void *) bptr, f.Length());
      if (f.Error())
      {
         using namespace BasicUI;
         ShowMessageBox(
            XO("Unable to read presets file."),
            MessageBoxOptions{}
               .Caption(XO("Error Loading VST Presets")));
         break;
      }
 
      // Get (or default) currently selected program
      int i = 0; //mProgram->GetCurrentSelection();
      if (i < 0)
      {
         i = 0;   // default to first program
      }
 
      // Go verify and set the program
      ret = LoadFXProgram(&bptr, len, i, false);
   } while (false);
 
   return ret;
}

References BasicUI::MessageBoxOptions::Caption(), fn, LoadFXProgram(), BasicUI::ShowMessageBox(), wxT(), and XO().

Referenced by VSTEffect::ImportPresetsNC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadFXProgram()

bool VSTWrapper::LoadFXProgram	(	unsigned char **	bptr,
		ssize_t &	len,
		int	index,
		bool	dryrun
	)

Definition at line 983 of file VSTWrapper.cpp.

{
   // Most references to the data are via an "int" array
   int32_t *iptr = (int32_t *) *bptr;
 
   // Verify that we have at least enough for a program without parameters
   if (len < 28)
   {
      return false;
   }
 
   // Verify that we probably have an FX file
   if (wxINT32_SWAP_ON_LE(iptr[0]) != CCONST('C', 'c', 'n', 'K'))
   {
      return false;
   }
 
   // Ignore the size...sometimes it's there, other times it's zero
 
   // Get the version and verify
#if defined(IS_THIS_AN_FXP_ARTIFICAL_LIMITATION)
   int version = wxINT32_SWAP_ON_LE(iptr[3]);
   if (version != 1)
   {
      return false;
   }
#endif
 
   VstPatchChunkInfo info =
   {
      1,
      wxINT32_SWAP_ON_LE(iptr[4]),
      wxINT32_SWAP_ON_LE(iptr[5]),
      wxINT32_SWAP_ON_LE(iptr[6]),
      ""
   };
 
   // Ensure this program looks to belong to the current plugin
   if ((info.pluginUniqueID != mAEffect->uniqueID) &&
         (info.pluginVersion != mAEffect->version) &&
         (info.numElements != mAEffect->numParams))
   {
      return false;
   }
 
   // Get the number of parameters
   int numParams = info.numElements;
 
   // At this point, we have to have enough to include the program name as well
   if (len < 56)
   {
      return false;
   }
 
   // Get the program name
   wxString progName(wxString::From8BitData((char *)&iptr[7]));
 
   // Might be a regular program
   if (wxINT32_SWAP_ON_LE(iptr[2]) == CCONST('F', 'x', 'C', 'k'))
   {
      // We finally know the full length of the program
      int proglen = 56 + (numParams * sizeof(float));
 
      // Verify that we have enough for all of the parameter values
      if (len < proglen)
      {
         return false;
      }
 
      // Validate all of the parameter values
      for (int i = 0; i < numParams; i++)
      {
         uint32_t ival = wxUINT32_SWAP_ON_LE(iptr[14 + i]);
         float val = reinterpretAsFloat(ival);
         if (val < 0.0 || val > 1.0)
         {
            return false;
         }
      }
 
      // They look okay...time to start changing things
      if (!dryrun)
      {
         // Ask the effect if this is an acceptable program
         if (callDispatcher(effBeginLoadProgram, 0, 0, &info, 0.0) == -1)
         {
            return false;
         }
 
         // Load all of the parameters
         callDispatcher(effBeginSetProgram, 0, 0, NULL, 0.0);
         for (int i = 0; i < numParams; i++)
         {
            wxUint32 val = wxUINT32_SWAP_ON_LE(iptr[14 + i]);
            callSetParameter(i, reinterpretAsFloat(val));
         }
         callDispatcher(effEndSetProgram, 0, 0, NULL, 0.0);
      }
 
      // Update in case we're loading an "FxBk" format bank file
      *bptr += proglen;
      len -= proglen;
   }
   // Maybe we have a program chunk
   else if (wxINT32_SWAP_ON_LE(iptr[2]) == CCONST('F', 'P', 'C', 'h'))
   {
      // Can't load programs chunks if the plugin doesn't support it
      if (!(mAEffect->flags & effFlagsProgramChunks))
      {
         return false;
      }
 
      // Verify that we have enough to grab the chunk size
      if (len < 60)
      {
         return false;
      }
 
      // Get the chunk size
      int size = wxINT32_SWAP_ON_LE(iptr[14]);
 
      // We finally know the full length of the program
      int proglen = 60 + size;
 
      // Verify that we have enough for the entire program
      if (len < proglen)
      {
         return false;
      }
 
      // Set the entire program in one shot
      if (!dryrun)
      {
         callSetChunk(true, size, &iptr[15], &info);
      }
 
      // Update in case we're loading an "FxBk" format bank file
      *bptr += proglen;
      len -= proglen;
   }
   else
   {
      // Unknown type
      return false;
   }
 
   if (!dryrun)
   {
      SetString(effSetProgramName, wxString(progName), index);
   }
 
   return true;
}

References callDispatcher(), callSetChunk(), callSetParameter(), CCONST, effBeginLoadProgram, effBeginSetProgram, effEndSetProgram, effFlagsProgramChunks, effSetProgramName, AEffect::flags, mAEffect, VstPatchChunkInfo::numElements, AEffect::numParams, VstPatchChunkInfo::pluginUniqueID, VstPatchChunkInfo::pluginVersion, reinterpretAsFloat(), SetString(), size, AEffect::uniqueID, and AEffect::version.

Referenced by LoadFXB(), and LoadFXP().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadXML()

bool VSTWrapper::LoadXML ( const wxFileName & fn )

Definition at line 1137 of file VSTWrapper.cpp.

{
   mInChunk = false;
   mInSet = false;
 
   // default to read as XML file
   // Load the program
   XMLFileReader reader;
   bool ok = reader.Parse(this, fn.GetFullPath());
 
   // Something went wrong with the file, clean up
   if (mInSet)
   {
      callDispatcher(effEndSetProgram, 0, 0, NULL, 0.0);
 
      mInSet = false;
   }
 
   if (!ok)
   {
      using namespace BasicUI;
      // Inform user of load failure
      ShowMessageBox(
         reader.GetErrorStr(),
         MessageBoxOptions{}
            .Caption(XO("Error Loading VST Presets")));
      return false;
   }
 
   return true;
}

References callDispatcher(), BasicUI::MessageBoxOptions::Caption(), effEndSetProgram, fn, XMLFileReader::GetErrorStr(), mInChunk, mInSet, XMLFileReader::Parse(), BasicUI::ShowMessageBox(), and XO().

Referenced by VSTEffect::ImportPresetsNC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeMessageFS()

std::unique_ptr< EffectInstance::Message > VSTWrapper::MakeMessageFS ( const VSTSettings & settings ) const

Definition at line 1819 of file VSTWrapper.cpp.

{
   VSTMessage::ParamVector paramVector;
   paramVector.resize(mAEffect->numParams, std::nullopt);
 
   ForEachParameter
   (
      [&](const VSTWrapper::ParameterInfo& pi)
      {
         auto &slot = paramVector[pi.mID]; // operator [] may make a nullopt
         const auto iter = settings.mParamsMap.find(pi.mName),
            end = settings.mParamsMap.end();
         if (iter != end)
            slot = iter->second;
         return true;
      }
   );
 
   return std::make_unique<VSTMessage>(
      settings.mChunk /* vector copy */, std::move(paramVector));
}

References details::end(), ForEachParameter(), mAEffect, AEffect::numParams, MIR::anonymous_namespace{MirUtils.cpp}::pi, and settings().

Referenced by VSTEffect::ImportPresetsNC(), VSTEffectBase::LoadFactoryPreset(), VSTEffectBase::LoadUserPreset(), and VSTEditor::VSTEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetModuleAndHandle()

void VSTWrapper::ResetModuleAndHandle ( )

Definition at line 583 of file VSTWrapper.cpp.

{
   if (mModule)
   {
#if defined(__WXMAC__)
      mResource.reset();
      mBundleRef.reset();
#endif
 
      mModule.reset();
      mAEffect = NULL;
   }
}

References mAEffect, mBundleRef, mModule, mResource, and VSTWrapper::ResourceHandle::reset().

Referenced by Load(), and ~VSTWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveFXB()

void VSTWrapper::SaveFXB ( const wxFileName & fn ) const

Definition at line 1169 of file VSTWrapper.cpp.

{
   // Create/Open the file
   const wxString fullPath{fn.GetFullPath()};
   wxFFile f(fullPath, wxT("wb"));
   if (!f.IsOpened())
   {
      using namespace BasicUI;
      ShowMessageBox(
         XO("Could not open file: \"%s\"").Format( fullPath ),
         MessageBoxOptions{}
            .Caption(XO("Error Saving VST Presets")));
      return;
   }
 
   wxMemoryBuffer buf;
   wxInt32 subType;
   void *chunkPtr = nullptr;
   int chunkSize = 0;
   int dataSize = 148;
   wxInt32 tab[8];
   int curProg = 0 ; //mProgram->GetCurrentSelection();
 
   if (mAEffect->flags & effFlagsProgramChunks)
   {
      subType = CCONST('F', 'B', 'C', 'h');
 
      // read-only dispatcher function
      chunkSize = constCallDispatcher(effGetChunk, 0, 0, &chunkPtr, 0.0);
      dataSize += 4 + chunkSize;
   }
   else
   {
      subType = CCONST('F', 'x', 'B', 'k');
 
      for (int i = 0; i < mAEffect->numPrograms; i++)
      {
         SaveFXProgram(buf, i);
      }
 
      dataSize += buf.GetDataLen();
   }
 
   tab[0] = wxINT32_SWAP_ON_LE(CCONST('C', 'c', 'n', 'K'));
   tab[1] = wxINT32_SWAP_ON_LE(dataSize);
   tab[2] = wxINT32_SWAP_ON_LE(subType);
   tab[3] = wxINT32_SWAP_ON_LE(curProg >= 0 ? 2 : 1);
   tab[4] = wxINT32_SWAP_ON_LE(mAEffect->uniqueID);
   tab[5] = wxINT32_SWAP_ON_LE(mAEffect->version);
   tab[6] = wxINT32_SWAP_ON_LE(mAEffect->numPrograms);
   tab[7] = wxINT32_SWAP_ON_LE(curProg >= 0 ? curProg : 0);
 
   f.Write(tab, sizeof(tab));
   if (!f.Error())
   {
      char padding[124];
      memset(padding, 0, sizeof(padding));
      f.Write(padding, sizeof(padding));
 
      if (!f.Error())
      {
         if (mAEffect->flags & effFlagsProgramChunks)
         {
            wxInt32 size = wxINT32_SWAP_ON_LE(chunkSize);
            f.Write(&size, sizeof(size));
            f.Write(chunkPtr, chunkSize);
         }
         else
         {
            f.Write(buf.GetData(), buf.GetDataLen());
         }
      }
   }
 
   if (f.Error())
   {
      using namespace BasicUI;
      ShowMessageBox(
         XO("Error writing to file: \"%s\"").Format( fullPath ),
         MessageBoxOptions{}
            .Caption(XO("Error Saving VST Presets")));
   }
 
   f.Close();
 
   return;
}

References BasicUI::MessageBoxOptions::Caption(), CCONST, constCallDispatcher(), effFlagsProgramChunks, effGetChunk, AEffect::flags, fn, mAEffect, AEffect::numPrograms, SaveFXProgram(), BasicUI::ShowMessageBox(), size, AEffect::uniqueID, AEffect::version, wxT(), and XO().

Referenced by VSTEffect::ExportPresets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveFXP()

void VSTWrapper::SaveFXP ( const wxFileName & fn ) const

Definition at line 1257 of file VSTWrapper.cpp.

{
   // Create/Open the file
   const wxString fullPath{ fn.GetFullPath() };
   wxFFile f(fullPath, wxT("wb"));
   if (!f.IsOpened())
   {
      using namespace BasicUI;
      ShowMessageBox(
         XO("Could not open file: \"%s\"").Format( fullPath ),
         MessageBoxOptions{}
            .Caption(XO("Error Saving VST Presets")));
      return;
   }
 
   wxMemoryBuffer buf;
 
   // read-only dispatcher function
   int ndx = constCallDispatcher(effGetProgram, 0, 0, NULL, 0.0);
   SaveFXProgram(buf, ndx);
 
   f.Write(buf.GetData(), buf.GetDataLen());
   if (f.Error())
   {
      using namespace BasicUI;
      ShowMessageBox(
         XO("Error writing to file: \"%s\"").Format( fullPath ),
         MessageBoxOptions{}
            .Caption(XO("Error Saving VST Presets")));
   }
 
   f.Close();
 
   return;
}

References BasicUI::MessageBoxOptions::Caption(), constCallDispatcher(), effGetProgram, fn, SaveFXProgram(), BasicUI::ShowMessageBox(), wxT(), and XO().

Referenced by VSTEffect::ExportPresets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveFXProgram()

void VSTWrapper::SaveFXProgram	(	wxMemoryBuffer &	buf,
		int	index
	)		const

Definition at line 1293 of file VSTWrapper.cpp.

{
   wxInt32 subType;
   void *chunkPtr;
   int chunkSize;
   int dataSize = 48;
   char progName[28];
   wxInt32 tab[7];
 
   // read-only dispatcher function
   constCallDispatcher(effGetProgramNameIndexed, index, 0, &progName, 0.0);
   progName[27] = '\0';
   chunkSize = strlen(progName);
   memset(&progName[chunkSize], 0, sizeof(progName) - chunkSize);
 
   if (mAEffect->flags & effFlagsProgramChunks)
   {
      subType = CCONST('F', 'P', 'C', 'h');
 
      // read-only dispatcher function
      chunkSize = constCallDispatcher(effGetChunk, 1, 0, &chunkPtr, 0.0);
      dataSize += 4 + chunkSize;
   }
   else
   {
      subType = CCONST('F', 'x', 'C', 'k');
 
      dataSize += (mAEffect->numParams << 2);
   }
 
   tab[0] = wxINT32_SWAP_ON_LE(CCONST('C', 'c', 'n', 'K'));
   tab[1] = wxINT32_SWAP_ON_LE(dataSize);
   tab[2] = wxINT32_SWAP_ON_LE(subType);
   tab[3] = wxINT32_SWAP_ON_LE(1);
   tab[4] = wxINT32_SWAP_ON_LE(mAEffect->uniqueID);
   tab[5] = wxINT32_SWAP_ON_LE(mAEffect->version);
   tab[6] = wxINT32_SWAP_ON_LE(mAEffect->numParams);
 
   buf.AppendData(tab, sizeof(tab));
   buf.AppendData(progName, sizeof(progName));
 
   if (mAEffect->flags & effFlagsProgramChunks)
   {
      wxInt32 size = wxINT32_SWAP_ON_LE(chunkSize);
      buf.AppendData(&size, sizeof(size));
      buf.AppendData(chunkPtr, chunkSize);
   }
   else
   {
      for (int i = 0; i < mAEffect->numParams; i++)
      {
         float val = callGetParameter(i);
         wxUint32 ival = wxUINT32_SWAP_ON_LE(reinterpretAsUint32(val));
         buf.AppendData(&ival, sizeof(ival));
      }
   }
 
   return;
}

References callGetParameter(), CCONST, constCallDispatcher(), effFlagsProgramChunks, effGetChunk, effGetProgramNameIndexed, AEffect::flags, mAEffect, AEffect::numParams, reinterpretAsUint32(), size, AEffect::uniqueID, and AEffect::version.

Referenced by SaveFXB(), and SaveFXP().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveXML()

void VSTWrapper::SaveXML ( const wxFileName & fn ) const

Definition at line 1354 of file VSTWrapper.cpp.

{
   XMLFileWriter xmlFile{ fn.GetFullPath(), XO("Error Saving Effect Presets") };
 
   xmlFile.StartTag(wxT("vstprogrampersistence"));
   xmlFile.WriteAttr(wxT("version"), wxT("2"));
 
   xmlFile.StartTag(wxT("effect"));
   // Use internal name only in persistent information
   xmlFile.WriteAttr(wxT("name"), GetSymbol().Internal());
   xmlFile.WriteAttr(wxT("uniqueID"), mAEffect->uniqueID);
   xmlFile.WriteAttr(wxT("version"), mAEffect->version);
   xmlFile.WriteAttr(wxT("numParams"), mAEffect->numParams);
 
   xmlFile.StartTag(wxT("program"));
   xmlFile.WriteAttr(wxT("name"), wxEmptyString); //mProgram->GetValue());
 
   int clen = 0;
   if (mAEffect->flags & effFlagsProgramChunks)
   {
      void *chunk = NULL;
 
      // read-only dispatcher function
      clen = (int) constCallDispatcher(effGetChunk, 1, 0, &chunk, 0.0);
      if (clen != 0)
      {
         xmlFile.StartTag(wxT("chunk"));
         xmlFile.WriteSubTree(Base64::Encode(chunk, clen) + wxT('\n'));
         xmlFile.EndTag(wxT("chunk"));
      }
   }
 
   if (clen == 0)
   {
      for (int i = 0; i < mAEffect->numParams; i++)
      {
         xmlFile.StartTag(wxT("param"));
 
         xmlFile.WriteAttr(wxT("index"), i);
         xmlFile.WriteAttr(wxT("name"),
                           GetString(effGetParamName, i));
         xmlFile.WriteAttr(wxT("value"),
                           wxString::Format(wxT("%f"),
                           callGetParameter(i)));
 
         xmlFile.EndTag(wxT("param"));
      }
   }
 
   xmlFile.EndTag(wxT("program"));
 
   xmlFile.EndTag(wxT("effect"));
 
   xmlFile.EndTag(wxT("vstprogrampersistence"));
 
   xmlFile.Commit();
}

References callGetParameter(), constCallDispatcher(), effFlagsProgramChunks, effGetChunk, effGetParamName, Base64::Encode(), AEffect::flags, fn, GetString(), GetSymbol(), Internal, mAEffect, AEffect::numParams, AEffect::uniqueID, AEffect::version, wxT(), and XO().

Referenced by VSTEffect::ExportPresets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetBufferDelay()

void VSTWrapper::SetBufferDelay ( int samples )

virtual

Reimplemented in VSTInstance.

Definition at line 647 of file VSTWrapper.cpp.

648{

649}

Referenced by AudioMaster().

Here is the caller graph for this function:

◆ SetString()

void VSTWrapper::SetString	(	int	opcode,
		const wxString &	str,
		int	index = `0`
	)

Definition at line 674 of file VSTWrapper.cpp.

{
   char buf[256];
   strcpy(buf, str.Left(255).ToUTF8());
 
   callDispatcher(opcode, index, 0, buf, 0.0);
}

References callDispatcher(), and str.

Referenced by HandleXMLTag(), and LoadFXProgram().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StoreSettings()

bool VSTWrapper::StoreSettings ( const VSTSettings & vst3settings ) const

Definition at line 1764 of file VSTWrapper.cpp.

{
   // First, make sure settings are compatibile with the plugin
   if ((vstSettings.mUniqueID  != mAEffect->uniqueID)   ||
//       (vstSettings.mVersion   != mAEffect->version)    ||
       (vstSettings.mNumParams != mAEffect->numParams)      )
   {
      return false;
   }
 
 
   // Try using the chunk first (if available)
   auto &chunk = vstSettings.mChunk;
   if (!chunk.empty())
   {
      VstPatchChunkInfo info = { 1, mAEffect->uniqueID, mAEffect->version, mAEffect->numParams, "" };
      callSetChunk(true, chunk.size(), const_cast<char *>(chunk.data()), &info);
   }
 
 
   // Settings (like the message) may store both a chunk, and also accumulated
   // slider movements to reapply after the chunk change.  Or it might be
   // no chunk and id-value pairs only
 
   constCallDispatcher(effBeginSetProgram, 0, 0, NULL, 0.0);
 
   ForEachParameter
   (
      [&](const ParameterInfo& pi)
      {
         const auto itr = vstSettings.mParamsMap.find(pi.mName);
         if (itr != vstSettings.mParamsMap.end())
         {
            const float& value = *(itr->second);
 
            if (value >= -1.0 && value <= 1.0)
            {
               callSetParameter(pi.mID, value);
            }
         }
         return true;
      }
   );
 
   constCallDispatcher(effEndSetProgram, 0, 0, NULL, 0.0);
 
   return true;
}

References callSetChunk(), constCallDispatcher(), effBeginSetProgram, ForEachParameter(), mAEffect, VSTSettings::mChunk, VSTSettings::mNumParams, VSTSettings::mParamsMap, VSTSettings::mUniqueID, AEffect::numParams, MIR::anonymous_namespace{MirUtils.cpp}::pi, AEffect::uniqueID, and AEffect::version.

Referenced by VSTEffect::ExportPresets(), VSTInstance::ProcessInitialize(), VSTEffectBase::SaveUserPreset(), and VSTEditor::StoreSettingsToInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Unload()

void VSTWrapper::Unload ( )

Definition at line 571 of file VSTWrapper.cpp.

{
   if (mAEffect)
   {
      // Finally, close the plugin
      callDispatcher(effClose, 0, 0, NULL, 0.0);
      mAEffect = NULL;
   }
 
   //ResetModuleAndHandle();
}

References callDispatcher(), effClose, and mAEffect.

Referenced by Load(), and ~VSTWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ mAEffect

◆ mAudioIns

unsigned VSTWrapper::mAudioIns { 0 }

Definition at line 220 of file VSTWrapper.h.

Referenced by VSTInstance::GetAudioInCount(), VSTEffectBase::GetDescription(), VSTEffectBase::GetType(), and Load().

◆ mAudioOuts

unsigned VSTWrapper::mAudioOuts { 0 }

Definition at line 221 of file VSTWrapper.h.

Referenced by VSTInstance::GetAudioOutCount(), VSTEffectBase::GetDescription(), VSTEffectBase::GetType(), and Load().

◆ mAutomatable

bool VSTWrapper::mAutomatable

Definition at line 224 of file VSTWrapper.h.

Referenced by Load(), and VSTEffectBase::SupportsAutomation().

◆ mBufferDelay

int VSTWrapper::mBufferDelay { 0 }

Definition at line 266 of file VSTWrapper.h.

Referenced by VSTInstance::SetBufferDelay().

◆ mBundleRef

BundleHandle VSTWrapper::mBundleRef

Definition at line 235 of file VSTWrapper.h.

Referenced by Load(), and ResetModuleAndHandle().

◆ mChunk

wxString VSTWrapper::mChunk

Definition at line 171 of file VSTWrapper.h.

Referenced by VSTMessage::Assign(), VSTMessage::Clone(), HandleXMLContent(), HandleXMLEndTag(), and VSTMessage::Merge().

◆ mCurrentEffectID

intptr_t VSTWrapper::mCurrentEffectID {}

Definition at line 200 of file VSTWrapper.h.

Referenced by AudioMaster(), and Load().

◆ mDescription

wxString VSTWrapper::mDescription

Definition at line 217 of file VSTWrapper.h.

◆ mDispatcherLock

std::recursive_mutex VSTWrapper::mDispatcherLock

Definition at line 133 of file VSTWrapper.h.

Referenced by callDispatcher().

◆ mGui

bool VSTWrapper::mGui { false }

Definition at line 295 of file VSTWrapper.h.

Referenced by VSTInstance::HasGUI(), Load(), and VSTEffect::PopulateUI().

◆ mInChunk

bool VSTWrapper::mInChunk

Definition at line 170 of file VSTWrapper.h.

Referenced by HandleXMLContent(), HandleXMLEndTag(), HandleXMLTag(), and LoadXML().

◆ mInSet

bool VSTWrapper::mInSet

Definition at line 169 of file VSTWrapper.h.

Referenced by HandleXMLEndTag(), HandleXMLTag(), and LoadXML().

◆ mInteractive

bool VSTWrapper::mInteractive { false }

Definition at line 219 of file VSTWrapper.h.

Referenced by VSTEffectBase::IsInteractive(), and Load().

◆ mMainThreadId

std::thread::id VSTWrapper::mMainThreadId

Definition at line 125 of file VSTWrapper.h.

Referenced by VSTInstance::Automate(), VSTInstance::ChunkMustBeAppliedInMainThread(), and VSTInstance::RealtimeProcessStart().

◆ mMidiIns

int VSTWrapper::mMidiIns { 0 }

Definition at line 222 of file VSTWrapper.h.

◆ mMidiOuts

int VSTWrapper::mMidiOuts { 0 }

Definition at line 223 of file VSTWrapper.h.

◆ mModule

ModuleHandle VSTWrapper::mModule {}

Definition at line 214 of file VSTWrapper.h.

Referenced by Load(), and ResetModuleAndHandle().

◆ mName

wxString VSTWrapper::mName

Definition at line 166 of file VSTWrapper.h.

Referenced by GetSymbol(), and Load().

◆ mPath

PluginPath VSTWrapper::mPath

Definition at line 203 of file VSTWrapper.h.

Referenced by VSTEffectBase::GetPath(), VSTEffect::ImportPresets(), Load(), VSTEffectBase::MakeInstance(), and VSTInstance::RealtimeAddProcessor().

◆ mProcessLevel

int VSTWrapper::mProcessLevel { 1 }

Definition at line 269 of file VSTWrapper.h.

Referenced by GetProcessLevel().

◆ mResource

ResourceHandle VSTWrapper::mResource

Definition at line 258 of file VSTWrapper.h.

Referenced by Load(), and ResetModuleAndHandle().

◆ mTimeInfo

VstTimeInfo VSTWrapper::mTimeInfo

Definition at line 264 of file VSTWrapper.h.

Referenced by VSTInstance::DoProcessInitialize(), GetSampleRate(), GetTimeInfo(), VSTInstance::ProcessBlock(), and VSTInstance::VSTInstance().

◆ mVendor

wxString VSTWrapper::mVendor

Definition at line 216 of file VSTWrapper.h.

Referenced by VSTEffectBase::GetVendor(), Load(), and VSTInstance::VSTInstance().

◆ mVersion

int VSTWrapper::mVersion

Definition at line 218 of file VSTWrapper.h.

Referenced by VSTEffectBase::GetVersion(), Load(), and VSTEffectBase::LoadSettings().

◆ mVstVersion

int VSTWrapper::mVstVersion

Definition at line 165 of file VSTWrapper.h.

Referenced by callSetParameter(), VSTEffectBase::GetEffectIDs(), VSTEffectBase::GetFactoryPresets(), Load(), VSTInstance::PowerOff(), and VSTInstance::PowerOn().

◆ mXMLInfo

VstPatchChunkInfo VSTWrapper::mXMLInfo

Definition at line 173 of file VSTWrapper.h.

Referenced by HandleXMLEndTag(), and HandleXMLTag().

◆ mXMLVersion

long VSTWrapper::mXMLVersion

Definition at line 172 of file VSTWrapper.h.

Referenced by HandleXMLTag().

The documentation for this struct was generated from the following files:

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ BundleHandle

◆ ModuleHandle

◆ ParameterVisitor

Constructor & Destructor Documentation

◆ VSTWrapper()

◆ ~VSTWrapper()

Member Function Documentation

◆ AudioMaster()

◆ callDispatcher()

◆ callGetParameter()

◆ callSetChunk() [1/2]

◆ callSetChunk() [2/2]

◆ callSetParameter()

◆ callSetProgram()

◆ constCallDispatcher()

◆ FetchSettings()

◆ ForEachParameter()

◆ GetChunkInfo()

◆ GetProcessLevel()

◆ GetSampleRate()

◆ GetSettings() [1/2]

◆ GetSettings() [2/2]

◆ GetString() [1/2]

◆ GetString() [2/2]

◆ GetSymbol()

◆ GetTimeInfo()

◆ HandleXMLChild()

◆ HandleXMLContent()

◆ HandleXMLEndTag()

◆ HandleXMLTag()

◆ IsCompatible()

◆ Load()

◆ LoadFXB()

◆ LoadFXP()

◆ LoadFXProgram()

◆ LoadXML()

◆ MakeMessageFS()

◆ ResetModuleAndHandle()

◆ SaveFXB()

◆ SaveFXP()

◆ SaveFXProgram()

◆ SaveXML()

◆ SetBufferDelay()

◆ SetString()

◆ StoreSettings()

◆ Unload()

Member Data Documentation

◆ mAEffect

◆ mAudioIns

◆ mAudioOuts

◆ mAutomatable

◆ mBufferDelay

◆ mBundleRef

◆ mChunk

◆ mCurrentEffectID

◆ mDescription

◆ mDispatcherLock

◆ mGui

◆ mInChunk

◆ mInSet

◆ mInteractive

◆ mMainThreadId

◆ mMidiIns

◆ mMidiOuts

◆ mModule

◆ mName

◆ mPath

◆ mProcessLevel

◆ mResource

◆ mTimeInfo

◆ mVendor

◆ mVersion

◆ mVstVersion