#include <VSTEffect.h>

Inheritance diagram for VSTEffectWrapper:

Collaboration diagram for VSTEffectWrapper:

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
	VSTEffectWrapper (const PluginPath &path)

	~VSTEffectWrapper ()

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 (VSTEffectSettings &vst3Settings, bool doFetch=true) const

bool	StoreSettings (const VSTEffectSettings &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	UpdateDisplay ()

virtual void	SetBufferDelay (int samples)

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

Public Member Functions inherited from VSTEffectLink
virtual	~VSTEffectLink ()

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 VSTEffectUIWrapper
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 VSTEffectSettings &	GetSettings (EffectSettings &settings)

static const VSTEffectSettings &	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 112 of file VSTEffect.h.

Member Typedef Documentation

◆ BundleHandle

using VSTEffectWrapper::BundleHandle = CF_ptr<CFBundleRef>

Definition at line 245 of file VSTEffect.h.

◆ ModuleHandle

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

Definition at line 218 of file VSTEffect.h.

◆ ParameterVisitor

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

Returns: true continue visiting; false stop visiting

Definition at line 163 of file VSTEffect.h.

Constructor & Destructor Documentation

◆ VSTEffectWrapper()

VSTEffectWrapper::VSTEffectWrapper ( const PluginPath & path )

inlineexplicit

Definition at line 128 of file VSTEffect.h.

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

◆ ~VSTEffectWrapper()

VSTEffectWrapper::~VSTEffectWrapper ( )

Definition at line 2058 of file VSTEffect.cpp.

{
   Unload();
   ResetModuleAndHandle();
}

References ResetModuleAndHandle(), and Unload().

Here is the call graph for this function:

Member Function Documentation

◆ AudioMaster()

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

static

Definition at line 604 of file VSTEffect.cpp.

{
   VSTEffectWrapper* vst = (effect ? static_cast<VSTEffectWrapper*>(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)
         {
            vst->UpdateDisplay();
            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:
         wxYieldIfNeeded();
         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, VSTEffectUIWrapper::Automate(), GetProcessLevel(), GetSampleRate(), GetTimeInfo(), AEffect::initialDelay, kVstLangEnglish, mCurrentEffectID, VSTEffectUIWrapper::NeedIdle(), AEffect::ptr2, SetBufferDelay(), VSTEffectUIWrapper::SizeWindow(), UpdateDisplay(), and wxT().

Referenced by Load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callDispatcher()

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

overridevirtual

Implements VSTEffectLink.

Definition at line 2456 of file VSTEffect.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(), VSTEffectInstance::DoProcessInitialize(), VSTEffect::GetEffectIDs(), HandleXMLEndTag(), HandleXMLTag(), Load(), LoadFXB(), LoadFXProgram(), LoadXML(), VSTEffectEditor::OnTimer(), VSTEffectInstance::PowerOff(), VSTEffectInstance::PowerOn(), SetString(), and Unload().

Here is the caller graph for this function:

◆ callGetParameter()

float VSTEffectWrapper::callGetParameter ( int index ) const

Definition at line 2481 of file VSTEffect.cpp.

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

References AEffect::getParameter, and mAEffect.

Referenced by FetchSettings(), and SaveFXProgram().

Here is the caller graph for this function:

◆ callSetChunk() [1/2]

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

Definition at line 2507 of file VSTEffect.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 VSTEffectInstance::ApplyChunk(), callSetChunk(), HandleXMLEndTag(), LoadFXB(), LoadFXProgram(), VSTEffect::LoadUserPreset(), and StoreSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callSetChunk() [2/2]

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

Definition at line 2520 of file VSTEffect.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 VSTEffectWrapper::callSetParameter	(	int	index,
		float	value
	)		const

Definition at line 2488 of file VSTEffect.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 VSTEffectInstance::RealtimeProcessStart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callSetProgram()

void VSTEffectWrapper::callSetProgram ( int index )

Definition at line 2497 of file VSTEffect.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 VSTEffect::DoLoadFactoryPreset(), Load(), and LoadFXB().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ constCallDispatcher()

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

Definition at line 2465 of file VSTEffect.cpp.

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

References callDispatcher().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchSettings()

bool VSTEffectWrapper::FetchSettings	(	VSTEffectSettings &	vst3Settings,
		bool	doFetch = `true`
	)		const

Definition at line 3783 of file VSTEffect.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, VSTEffectSettings::mChunk, VSTEffectWrapper::ParameterInfo::mID, VSTEffectWrapper::ParameterInfo::mName, VSTEffectSettings::mNumParams, VSTEffectSettings::mParamsMap, VSTEffectSettings::mUniqueID, VSTEffectSettings::mVersion, AEffect::numParams, size, AEffect::uniqueID, and AEffect::version.

Referenced by VSTEffectEditor::FetchSettingsFromInstance(), VSTEffect::ImportPresetsNC(), VSTEffect::LoadFactoryPreset(), VSTEffect::LoadUserPreset(), VSTEffectInstance::MakeMessage(), and VSTEffect::MakeSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ForEachParameter()

void VSTEffectWrapper::ForEachParameter ( ParameterVisitor visitor ) const

Definition at line 3756 of file VSTEffect.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, TranslatableString::empty(), GetString(), mAEffect, name, CommandParameters::NormalizeName(), AEffect::numParams, and wxT().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetChunkInfo()

VstPatchChunkInfo VSTEffectWrapper::GetChunkInfo ( ) const

Definition at line 2087 of file VSTEffect.cpp.

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

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

Referenced by VSTEffect::LoadUserPreset().

Here is the caller graph for this function:

◆ GetProcessLevel()

int VSTEffectWrapper::GetProcessLevel ( )

Definition at line 2271 of file VSTEffect.cpp.

{
   return mProcessLevel;
}

References mProcessLevel.

Referenced by AudioMaster().

Here is the caller graph for this function:

◆ GetSampleRate()

float VSTEffectWrapper::GetSampleRate ( )

Definition at line 2266 of file VSTEffect.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 VSTEffectSettings & VSTEffectWrapper::GetSettings ( const EffectSettings & settings )

inlinestatic

Definition at line 121 of file VSTEffect.h.

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

References settings().

Here is the call graph for this function:

◆ GetSettings() [2/2]

static VSTEffectSettings & VSTEffectWrapper::GetSettings ( EffectSettings & settings )

inlinestatic

Definition at line 114 of file VSTEffect.h.

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

References settings().

Referenced by VSTEffect::ExportPresets(), VSTEffect::ImportPresetsNC(), VSTEffect::LoadFactoryPreset(), VSTEffect::LoadSettings(), VSTEffect::LoadUserPreset(), VSTEffectEditor::NotifyParameterChanged(), VSTEffectInstance::ProcessInitialize(), VSTEffect::SaveSettings(), VSTEffect::SaveUserPreset(), and VSTEffectEditor::VSTEffectEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetString() [1/2]

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

Definition at line 2439 of file VSTEffect.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 VSTEffectWrapper::GetString	(	wxString &	outstr,
		int	opcode,
		int	index = `0`
	)		const

Definition at line 2425 of file VSTEffect.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 VSTEffectEditor::BuildPlain(), ForEachParameter(), VSTEffect::GetFactoryPresets(), GetString(), Load(), and VSTEffectEditor::RefreshParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSymbol()

ComponentInterfaceSymbol VSTEffectWrapper::GetSymbol ( ) const

Definition at line 3890 of file VSTEffect.cpp.

{
   return mName;
}

References mName.

Referenced by VSTEffect::GetSymbol(), and HandleXMLTag().

Here is the caller graph for this function:

◆ GetTimeInfo()

VstTimeInfo * VSTEffectWrapper::GetTimeInfo ( )

Definition at line 2260 of file VSTEffect.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 * VSTEffectWrapper::HandleXMLChild ( const std::string_view & tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 3725 of file VSTEffect.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 VSTEffectWrapper::HandleXMLContent ( const std::string_view & content )

override

Definition at line 3717 of file VSTEffect.cpp.

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

References mChunk, and mInChunk.

◆ HandleXMLEndTag()

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

override

Definition at line 3687 of file VSTEffect.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 VSTEffectWrapper::HandleXMLTag	(	const std::string_view &	tag,
		const AttributesList &	attrs
	)

overridevirtual

Implements XMLTagHandler.

Definition at line 3479 of file VSTEffect.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())
            {
               auto msg = XO("This parameter file was saved from %s. Continue?")
                  .Format( strValue );
               int result = AudacityMessageBox(
                  msg,
                  XO("Confirm"),
                  wxYES_NO,
                  nullptr );
               if (result == wxNO)
               {
                  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 AudacityMessageBox(), callDispatcher(), callSetParameter(), effBeginLoadProgram, effBeginSetProgram, effSetProgramName, GetSymbol(), Internal, mAEffect, mInChunk, mInSet, mXMLInfo, mXMLVersion, VstPatchChunkInfo::numElements, AEffect::numParams, VstPatchChunkInfo::pluginUniqueID, VstPatchChunkInfo::pluginVersion, SetString(), AEffect::uniqueID, AEffect::version, VstPatchChunkInfo::version, and XO().

Here is the call graph for this function:

◆ IsCompatible()

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

Definition at line 2093 of file VSTEffect.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 VSTEffect::LoadUserPreset().

Here is the caller graph for this function:

◆ Load()

bool VSTEffectWrapper::Load ( )

Definition at line 1765 of file VSTEffect.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(VSTEffectWrapper::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<VSTEffectWrapper*>(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(), VSTEffect::InitializePlugin(), and VSTEffectInstance::VSTEffectInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadFXB()

bool VSTEffectWrapper::LoadFXB ( const wxFileName & fn )

Definition at line 2824 of file VSTEffect.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)
   {
      AudacityMessageBox(
         XO("Unable to allocate memory when loading presets file."),
         XO("Error Loading VST Presets"),
         wxOK | wxCENTRE,
         nullptr);
      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())
      {
         AudacityMessageBox(
            XO("Unable to read presets file."),
            XO("Error Loading VST Presets"),
            wxOK | wxCENTRE,
            nullptr);
         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 AudacityMessageBox(), callDispatcher(), callSetChunk(), callSetProgram(), CCONST, effBeginLoadBank, effFlagsProgramChunks, AEffect::flags, fn, LoadFXProgram(), mAEffect, VstPatchChunkInfo::numElements, AEffect::numPrograms, VstPatchChunkInfo::pluginUniqueID, VstPatchChunkInfo::pluginVersion, 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 VSTEffectWrapper::LoadFXP ( const wxFileName & fn )

Definition at line 2997 of file VSTEffect.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)
   {
      AudacityMessageBox(
         XO("Unable to allocate memory when loading presets file."),
         XO("Error Loading VST Presets"),
         wxOK | wxCENTRE,
         nullptr);
      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())
      {
         AudacityMessageBox(
            XO("Unable to read presets file."),
            XO("Error Loading VST Presets"),
            wxOK | wxCENTRE,
            nullptr);
         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 AudacityMessageBox(), fn, LoadFXProgram(), 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 VSTEffectWrapper::LoadFXProgram	(	unsigned char **	bptr,
		ssize_t &	len,
		int	index,
		bool	dryrun
	)

Definition at line 3049 of file VSTEffect.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 VSTEffectWrapper::LoadXML ( const wxFileName & fn )

Definition at line 3203 of file VSTEffect.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)
   {
      // Inform user of load failure
      AudacityMessageBox(
         reader.GetErrorStr(),
         XO("Error Loading VST Presets"),
         wxOK | wxCENTRE,
         nullptr);
      return false;
   }
 
   return true;
}

References AudacityMessageBox(), callDispatcher(), effEndSetProgram, fn, XMLFileReader::GetErrorStr(), mInChunk, mInSet, XMLFileReader::Parse(), 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 > VSTEffectWrapper::MakeMessageFS ( const VSTEffectSettings & settings ) const

Definition at line 3910 of file VSTEffect.cpp.

{
   VSTEffectMessage::ParamVector paramVector;
   paramVector.resize(mAEffect->numParams, std::nullopt);
 
   ForEachParameter
   (
      [&](const VSTEffectWrapper::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<VSTEffectMessage>(
      settings.mChunk /* vector copy */, std::move(paramVector));
}

References PackedArray::end(), ForEachParameter(), mAEffect, VSTEffectWrapper::ParameterInfo::mID, VSTEffectWrapper::ParameterInfo::mName, AEffect::numParams, and settings().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetModuleAndHandle()

void VSTEffectWrapper::ResetModuleAndHandle ( )

Definition at line 2043 of file VSTEffect.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveFXB()

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

Definition at line 3235 of file VSTEffect.cpp.

{
   // Create/Open the file
   const wxString fullPath{fn.GetFullPath()};
   wxFFile f(fullPath, wxT("wb"));
   if (!f.IsOpened())
   {
      AudacityMessageBox(
         XO("Could not open file: \"%s\"").Format( fullPath ),
         XO("Error Saving VST Presets"),
         wxOK | wxCENTRE,
         nullptr);
      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())
   {
      AudacityMessageBox(
         XO("Error writing to file: \"%s\"").Format( fullPath ),
         XO("Error Saving VST Presets"),
         wxOK | wxCENTRE,
         nullptr);
   }
 
   f.Close();
 
   return;
}

References AudacityMessageBox(), CCONST, constCallDispatcher(), effFlagsProgramChunks, effGetChunk, AEffect::flags, fn, mAEffect, AEffect::numPrograms, SaveFXProgram(), 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 VSTEffectWrapper::SaveFXP ( const wxFileName & fn ) const

Definition at line 3323 of file VSTEffect.cpp.

{
   // Create/Open the file
   const wxString fullPath{ fn.GetFullPath() };
   wxFFile f(fullPath, wxT("wb"));
   if (!f.IsOpened())
   {
      AudacityMessageBox(
         XO("Could not open file: \"%s\"").Format( fullPath ),
         XO("Error Saving VST Presets"),
         wxOK | wxCENTRE,
         nullptr);
      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())
   {
      AudacityMessageBox(
         XO("Error writing to file: \"%s\"").Format( fullPath ),
         XO("Error Saving VST Presets"),
         wxOK | wxCENTRE,
         nullptr);
   }
 
   f.Close();
 
   return;
}

References AudacityMessageBox(), constCallDispatcher(), effGetProgram, fn, SaveFXProgram(), 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 VSTEffectWrapper::SaveFXProgram	(	wxMemoryBuffer &	buf,
		int	index
	)		const

Definition at line 3359 of file VSTEffect.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 VSTEffectWrapper::SaveXML ( const wxFileName & fn ) const

Definition at line 3420 of file VSTEffect.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 effFlagsProgramChunks, effGetChunk, effGetParamName, Base64::Encode(), fn, Internal, 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 VSTEffectWrapper::SetBufferDelay ( int samples )

virtual

Reimplemented in VSTEffectInstance.

Definition at line 2409 of file VSTEffect.cpp.

2410{

2411}

Referenced by AudioMaster().

Here is the caller graph for this function:

◆ SetString()

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

Definition at line 2448 of file VSTEffect.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 VSTEffectWrapper::StoreSettings ( const VSTEffectSettings & vst3settings ) const

Definition at line 3833 of file VSTEffect.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, VSTEffectSettings::mChunk, VSTEffectWrapper::ParameterInfo::mName, VSTEffectSettings::mNumParams, VSTEffectSettings::mParamsMap, VSTEffectSettings::mUniqueID, AEffect::numParams, AEffect::uniqueID, and AEffect::version.

Referenced by VSTEffect::ExportPresets(), VSTEffectInstance::ProcessInitialize(), VSTEffect::SaveUserPreset(), and VSTEffectEditor::StoreSettingsToInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Unload()

void VSTEffectWrapper::Unload ( )

Definition at line 2030 of file VSTEffect.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 ~VSTEffectWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDisplay()

void VSTEffectWrapper::UpdateDisplay ( )

virtual

Reimplemented in VSTEffect.

Definition at line 3975 of file VSTEffect.cpp.

3976{

3977}

Referenced by AudioMaster().

Here is the caller graph for this function:

Member Data Documentation

◆ mAEffect

◆ mAudioIns

unsigned VSTEffectWrapper::mAudioIns { 0 }

Definition at line 232 of file VSTEffect.h.

Referenced by VSTEffectInstance::GetAudioInCount(), VSTEffect::GetDescription(), VSTEffect::GetType(), and Load().

◆ mAudioOuts

unsigned VSTEffectWrapper::mAudioOuts { 0 }

Definition at line 233 of file VSTEffect.h.

Referenced by VSTEffectInstance::GetAudioOutCount(), VSTEffect::GetDescription(), VSTEffect::GetType(), and Load().

◆ mAutomatable

bool VSTEffectWrapper::mAutomatable

Definition at line 236 of file VSTEffect.h.

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

◆ mBufferDelay

int VSTEffectWrapper::mBufferDelay { 0 }

Definition at line 278 of file VSTEffect.h.

Referenced by VSTEffectInstance::SetBufferDelay().

◆ mBundleRef

BundleHandle VSTEffectWrapper::mBundleRef

Definition at line 247 of file VSTEffect.h.

Referenced by Load(), and ResetModuleAndHandle().

◆ mChunk

wxString VSTEffectWrapper::mChunk

Definition at line 182 of file VSTEffect.h.

Referenced by HandleXMLContent(), and HandleXMLEndTag().

◆ mCurrentEffectID

intptr_t VSTEffectWrapper::mCurrentEffectID {}

Definition at line 211 of file VSTEffect.h.

Referenced by AudioMaster(), and Load().

◆ mDescription

wxString VSTEffectWrapper::mDescription

Definition at line 229 of file VSTEffect.h.

◆ mDispatcherLock

std::recursive_mutex VSTEffectWrapper::mDispatcherLock

Definition at line 144 of file VSTEffect.h.

Referenced by callDispatcher().

◆ mGui

bool VSTEffectWrapper::mGui { false }

Definition at line 310 of file VSTEffect.h.

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

◆ mInChunk

bool VSTEffectWrapper::mInChunk

Definition at line 181 of file VSTEffect.h.

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

◆ mInSet

bool VSTEffectWrapper::mInSet

Definition at line 180 of file VSTEffect.h.

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

◆ mInteractive

bool VSTEffectWrapper::mInteractive { false }

Definition at line 231 of file VSTEffect.h.

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

◆ mMainThreadId

std::thread::id VSTEffectWrapper::mMainThreadId

Definition at line 136 of file VSTEffect.h.

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

◆ mMidiIns

int VSTEffectWrapper::mMidiIns { 0 }

Definition at line 234 of file VSTEffect.h.

◆ mMidiOuts

int VSTEffectWrapper::mMidiOuts { 0 }

Definition at line 235 of file VSTEffect.h.

◆ mModule

ModuleHandle VSTEffectWrapper::mModule {}

Definition at line 226 of file VSTEffect.h.

Referenced by Load(), and ResetModuleAndHandle().

◆ mName

wxString VSTEffectWrapper::mName

Definition at line 177 of file VSTEffect.h.

Referenced by GetSymbol(), and Load().

◆ mPath

PluginPath VSTEffectWrapper::mPath

Definition at line 214 of file VSTEffect.h.

Referenced by VSTEffect::DoMakeInstance(), VSTEffect::GetPath(), VSTEffect::ImportPresets(), Load(), and VSTEffectInstance::RealtimeAddProcessor().

◆ mProcessLevel

int VSTEffectWrapper::mProcessLevel { 1 }

Definition at line 281 of file VSTEffect.h.

Referenced by GetProcessLevel().

◆ mResource

ResourceHandle VSTEffectWrapper::mResource

Definition at line 270 of file VSTEffect.h.

Referenced by Load(), and ResetModuleAndHandle().

◆ mTimeInfo

VstTimeInfo VSTEffectWrapper::mTimeInfo

Definition at line 276 of file VSTEffect.h.

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

◆ mVendor

wxString VSTEffectWrapper::mVendor

Definition at line 228 of file VSTEffect.h.

Referenced by VSTEffect::GetVendor(), Load(), and VSTEffectInstance::VSTEffectInstance().

◆ mVersion

int VSTEffectWrapper::mVersion

Definition at line 230 of file VSTEffect.h.

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

◆ mVstVersion

int VSTEffectWrapper::mVstVersion

Definition at line 176 of file VSTEffect.h.

Referenced by callSetParameter(), VSTEffect::GetEffectIDs(), VSTEffect::GetFactoryPresets(), Load(), VSTEffectInstance::PowerOff(), and VSTEffectInstance::PowerOn().

◆ mXMLInfo

VstPatchChunkInfo VSTEffectWrapper::mXMLInfo

Definition at line 184 of file VSTEffect.h.

Referenced by HandleXMLEndTag(), and HandleXMLTag().

◆ mXMLVersion

long VSTEffectWrapper::mXMLVersion

Definition at line 183 of file VSTEffect.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

◆ VSTEffectWrapper()

◆ ~VSTEffectWrapper()

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()

◆ UpdateDisplay()

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