#include <VST3Wrapper.h>

Collaboration diagram for VST3Wrapper:

Classes
struct	FactoryPresetDesc

Public Member Functions
	VST3Wrapper (VST3::Hosting::Module &module, const VST3::Hosting::ClassInfo &effectClassInfo)

	~VST3Wrapper ()

	VST3Wrapper (const VST3Wrapper &)=delete

	VST3Wrapper (VST3Wrapper &&)=delete

VST3Wrapper &	operator= (const VST3Wrapper &)=delete

VST3Wrapper &	operator= (VST3Wrapper &&)=delete

void	InitializeComponents ()
	Should be called once before almost any other method call. More...

VST3::Hosting::Module &	GetModule () const

const VST3::Hosting::ClassInfo &	GetEffectClassInfo () const

bool	IsActive () const noexcept

void	FetchSettings (EffectSettings &)
	Fetch state from settings object, may change internal runtime data. More...

void	StoreSettings (EffectSettings &) const
	Saves current state inside settings object, clears all runtime data. More...

void	LoadPreset (const wxString &presetId)

void	SavePresetToFile (const wxString &filepath) const

bool	Initialize (EffectSettings &settings, Steinberg::Vst::SampleRate sampleRate, Steinberg::int32 processMode, Steinberg::int32 maxSamplesPerBlock)
	Initializes effect for processing using settings. More...

void	Finalize (EffectSettings *settings)

void	ProcessBlockStart (const EffectSettings &settings)
	Prepares effect to process next block with changes written to the settings object. More...

void	FlushParameters (EffectSettings &settings, bool *hasChanges=nullptr)

size_t	Process (const float const inBlock, float const outBlock, size_t blockLen)

void	SuspendProcessing ()

void	ResumeProcessing ()

void	BeginParameterEdit (EffectSettingsAccess &access)

void	EndParameterEdit ()

std::vector< FactoryPresetDesc >	FindFactoryPresets () const

Steinberg::int32	GetLatencySamples () const

Static Public Member Functions
static EffectSettings	MakeSettings ()

static void	LoadSettings (const CommandParameters &parms, EffectSettings &settings)

static void	SaveSettings (const EffectSettings &settings, CommandParameters &parms)

static OptionalMessage	LoadUserPreset (const EffectDefinitionInterface &effect, const RegistryPath &name, EffectSettings &settings)

static void	SaveUserPreset (const EffectDefinitionInterface &effect, const RegistryPath &name, const EffectSettings &settings)

static void	CopySettingsContents (const EffectSettings &src, EffectSettings &dst)

Public Attributes
Steinberg::IPtr< Steinberg::Vst::IAudioProcessor >	mAudioProcessor

Steinberg::Vst::ProcessSetup	mSetup

Steinberg::IPtr< Steinberg::Vst::IComponent >	mEffectComponent

Steinberg::IPtr< Steinberg::Vst::IEditController >	mEditController

Steinberg::IPtr< Steinberg::Vst::IConnectionPoint >	mComponentConnectionProxy

Steinberg::IPtr< Steinberg::Vst::IConnectionPoint >	mControllerConnectionProxy

Steinberg::IPtr< Steinberg::Vst::IComponentHandler >	mComponentHandler

std::function< void(Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue)>	ParamChangedHandler

Private Member Functions
bool	LoadPresetFromStream (Steinberg::IBStream *fileStream)

bool	SavePresetToStream (Steinberg::IBStream *fileStream) const

void	ConsumeChanges (const EffectSettings &settings)

Private Attributes
EffectSettings	mDefaultSettings

VST3::Hosting::Module &	mModule

const VST3::Hosting::ClassInfo &	mEffectClassInfo

bool	mActive {false}

std::vector< std::pair< Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue > >	mParameters

std::unique_ptr< SingleInputParameterValue[]>	mParameterQueues

Steinberg::Vst::ProcessContext	mProcessContext { }

Detailed Description

Definition at line 54 of file VST3Wrapper.h.

Constructor & Destructor Documentation

◆ VST3Wrapper() [1/3]

VST3Wrapper::VST3Wrapper	(	VST3::Hosting::Module &	module,
		const VST3::Hosting::ClassInfo &	effectClassInfo
	)

Definition at line 407 of file VST3Wrapper.cpp.

   : mModule{ module }
   , mEffectClassInfo { effectClassInfo }
{
   using namespace Steinberg;
 
   const auto& pluginFactory = module.getFactory();
 
   auto effectComponent = pluginFactory.createInstance<Vst::IComponent>(effectClassInfo.ID());
   if(!effectComponent)
      throw std::runtime_error("Cannot create VST3 effect component");
   if(effectComponent->initialize(&AudacityVst3HostApplication::Get()) != kResultOk)
      throw std::runtime_error("Cannot initialize VST3 effect component");
 
   auto audioProcessor = FUnknownPtr<Vst::IAudioProcessor>(effectComponent);
   if(!audioProcessor)
      //It's stated that "This interface must always be supported by audio processing plug-ins."
      throw std::runtime_error("VST3 plugin does not provide audio processor interface");
   
   if(audioProcessor->canProcessSampleSize(Vst::kSample32) != kResultTrue)
      throw std::runtime_error("32-bit sample size not supported");
 
   mEffectComponent = effectComponent;
   mAudioProcessor = audioProcessor;
 
   auto editController = FUnknownPtr<Vst::IEditController>(mEffectComponent);
   if(editController.get() == nullptr)
   {
      TUID controllerCID;
            
      if (mEffectComponent->getControllerClassId (controllerCID) == kResultTrue)
         editController = pluginFactory.createInstance<Vst::IEditController>(VST3::UID(controllerCID));
   }
 
   if(editController.get() == nullptr)
      throw std::runtime_error("Failed to instantiate edit controller");
   
   mEditController = editController;
 
   mEditController->initialize(&AudacityVst3HostApplication::Get());
 
   mComponentHandler = owned(safenew ComponentHandler(*this));
   mEditController->setComponentHandler(mComponentHandler);
 
   const auto componentConnectionPoint = FUnknownPtr<Vst::IConnectionPoint>{ mEffectComponent };
   const auto controllerConnectionPoint = FUnknownPtr<Vst::IConnectionPoint>{ mEditController };
 
   if (componentConnectionPoint && controllerConnectionPoint)
   {
      mComponentConnectionProxy = owned(safenew internal::ConnectionProxy(componentConnectionPoint));
      mControllerConnectionProxy = owned(safenew internal::ConnectionProxy(controllerConnectionPoint));
 
      mComponentConnectionProxy->connect(controllerConnectionPoint);
      mControllerConnectionProxy->connect(componentConnectionPoint);
   }
   
   if(GetCache(mEffectClassInfo.ID()) == nullptr)
   {
      //First time instantiation...
      auto& cache = CreateCache(mEffectClassInfo.ID());
 
      //Find root unit program change parameter ID (if any)
      for(int32 parameterIndex = 0, parametersCount = mEditController->getParameterCount();
         parameterIndex < parametersCount;
         ++parameterIndex)
      {
         Vst::ParameterInfo parameterInfo {};
         if(mEditController->getParameterInfo(parameterIndex, parameterInfo) != kResultOk)
            continue;
 
         if(parameterInfo.unitId != Vst::kRootUnitId)
            continue;
         if((parameterInfo.flags & Vst::ParameterInfo::kIsProgramChange) == 0)
            continue;
         
         auto unitInfoProvider = FUnknownPtr<Vst::IUnitInfo>(mEditController);
         if(!unitInfoProvider)
            //Sanity check...
            break;
 
         for(int32 unitIndex = 0, unitCount = unitInfoProvider->getUnitCount();
           unitIndex < unitCount;
            ++unitIndex)
         {
            Vst::UnitInfo unitInfo{};
            if(unitInfoProvider->getUnitInfo(unitIndex, unitInfo) != kResultOk)
               continue;
 
            if(unitInfo.id != Vst::kRootUnitId)
               continue;
 
            for(int32 programListIndex = 0, programListCount = unitInfoProvider->getProgramListCount();
               programListIndex < programListCount;
               ++programListIndex)
            {
               Vst::ProgramListInfo programListInfo{};
               if(unitInfoProvider->getProgramListInfo(programListIndex, programListInfo) != kResultOk)
                  continue;
 
               if(programListInfo.id != unitInfo.programListId)//unitInfo.id == kRootUnitId
                  continue;
 
               cache.rootUnitProgramListID = programListInfo.id;
               cache.rootUnitProgramCount = programListInfo.programCount;
               break;
            }
            
            if(cache.rootUnitProgramListID == Vst::kNoProgramListId)
               cache.rootUnitProgramCount = parameterInfo.stepCount + 1;
            
            cache.rootUnitProgramChangeParameterID = parameterInfo.id;
 
            break;
         }
 
         break;
      }
   }
}

References anonymous_namespace{VST3Wrapper.cpp}::CreateCache(), AudacityVst3HostApplication::Get(), anonymous_namespace{VST3Wrapper.cpp}::GetCache(), mAudioProcessor, mComponentConnectionProxy, mComponentHandler, mControllerConnectionProxy, mEditController, mEffectClassInfo, mEffectComponent, and safenew.

Here is the call graph for this function:

◆ ~VST3Wrapper()

VST3Wrapper::~VST3Wrapper ( )

Definition at line 527 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   if(mComponentConnectionProxy)
      mComponentConnectionProxy->disconnect(FUnknownPtr<Vst::IConnectionPoint>(mEditController));
   if(mControllerConnectionProxy)
      mControllerConnectionProxy->disconnect(FUnknownPtr<Vst::IConnectionPoint>(mEffectComponent));
 
   if(mEditController)
   {
      mEditController->setComponentHandler(nullptr);
      mEditController->terminate();
   }
   if(mEffectComponent)
      mEffectComponent->terminate();
}

References mComponentConnectionProxy, mControllerConnectionProxy, mEditController, and mEffectComponent.

◆ VST3Wrapper() [2/3]

VST3Wrapper::VST3Wrapper ( const VST3Wrapper & )

delete

◆ VST3Wrapper() [3/3]

VST3Wrapper::VST3Wrapper ( VST3Wrapper && )

delete

Member Function Documentation

◆ BeginParameterEdit()

void VST3Wrapper::BeginParameterEdit ( EffectSettingsAccess & access )

Definition at line 959 of file VST3Wrapper.cpp.

{
   static_cast<ComponentHandler*>(mComponentHandler.get())->SetAccess(&access);
}

References mComponentHandler.

Referenced by VST3Editor::VST3Editor().

Here is the caller graph for this function:

◆ ConsumeChanges()

void VST3Wrapper::ConsumeChanges ( const EffectSettings & settings )

private

Definition at line 803 of file VST3Wrapper.cpp.

{
   const auto& vst3settings = GetSettings(settings);
   for(auto& p : vst3settings.parameterChanges)
   {
      auto it = std::find_if(mParameters.begin(), mParameters.end(), [&p](const auto& v) { return v.first == p.first; });
      if(it != mParameters.end())
         it->second = p.second;
      else
         mParameters.push_back(p);
   }
}

References anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mParameters, and settings().

Referenced by Finalize(), FlushParameters(), Initialize(), and ProcessBlockStart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopySettingsContents()

void VST3Wrapper::CopySettingsContents	(	const EffectSettings &	src,
		EffectSettings &	dst
	)

static

Definition at line 1103 of file VST3Wrapper.cpp.

{
   auto& from = GetSettings(*const_cast<EffectSettings*>(&src));
   auto& to = GetSettings(dst);
 
   //Don't allocate in worker
   std::swap(from.parameterChanges, to.parameterChanges);
}

References anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by VST3EffectBase::CopySettingsContents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndParameterEdit()

void VST3Wrapper::EndParameterEdit ( )

Definition at line 964 of file VST3Wrapper.cpp.

{
   auto componentHandler = static_cast<ComponentHandler*>(mComponentHandler.get());
   componentHandler->SetAccess(nullptr);
}

References mComponentHandler.

Referenced by VST3Editor::OnClose().

Here is the caller graph for this function:

◆ FetchSettings()

void VST3Wrapper::FetchSettings ( EffectSettings & settings )

Fetch state from settings object, may change internal runtime data.

Definition at line 593 of file VST3Wrapper.cpp.

{
   //TODO: perform version check
   {
      auto componentHandler = static_cast<ComponentHandler*>(mComponentHandler.get());
      componentHandler->ResetCache();
      componentHandler->BeginStateChange(settings);
      auto cleanup = finally([&] { componentHandler->EndStateChange(); });
 
      //Restore state
      const auto* vst3settings = &GetSettings(settings);
      if(!vst3settings->processorState.has_value())
         vst3settings = &GetSettings(GetCache(mEffectClassInfo.ID())->defaultSettings);
 
      if(vst3settings->processorState.has_value())
      {
         auto processorState = PresetsBufferStream::fromString(*vst3settings->processorState);
         processorState->seek(0, Steinberg::IBStream::kIBSeekSet);
         if(mEffectComponent->setState(processorState) == Steinberg::kResultOk)
         {
            processorState->seek(0, Steinberg::IBStream::kIBSeekSet);
            if(mEditController->setComponentState(processorState) == Steinberg::kResultOk)
            {
               if(vst3settings->controllerState.has_value())
               {
                  auto controllerState = PresetsBufferStream::fromString(*vst3settings->controllerState);
                  controllerState->seek(0, Steinberg::IBStream::kIBSeekSet);
                  mEditController->setState(controllerState);
               }
            }
         }
      }
   }
   //restore parameters if present
   auto& vst3setting = GetSettings(settings);
   for(auto& p : vst3setting.parameterChanges)
      mEditController->setParamNormalized(p.first, p.second);
}

References anonymous_namespace{VST3Wrapper.cpp}::VST3PluginCache::defaultSettings, PresetsBufferStream::fromString(), anonymous_namespace{VST3Wrapper.cpp}::GetCache(), anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mComponentHandler, mEditController, mEffectClassInfo, mEffectComponent, and settings().

Referenced by Initialize(), and VST3Editor::UpdateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Finalize()

void VST3Wrapper::Finalize ( EffectSettings * settings )

Frees up resources allocated for processing, should be called after processing is complete. Optionally settings object may be passed to update runtime data with current internal state.

Definition at line 780 of file VST3Wrapper.cpp.

{
   //Could be FlushParameters but processor is already configured
   //If no calls to process were performed deliver changes here
   mProcessContext.state = 0;
   if(settings != nullptr)
   {
      ConsumeChanges(*settings);
      Process(nullptr, nullptr, 0);
   }
   mAudioProcessor->setProcessing(false);
   mEffectComponent->setActive(false);
   mActive = false;
 
   if(settings != nullptr)
      StoreSettings(*settings);
}

References ConsumeChanges(), mActive, mAudioProcessor, mEffectComponent, mProcessContext, Process(), settings(), and StoreSettings().

Here is the call graph for this function:

◆ FindFactoryPresets()

std::vector< VST3Wrapper::FactoryPresetDesc > VST3Wrapper::FindFactoryPresets ( ) const

Returns an array of factory preset ids. Safe to call before InitializeComponents

Definition at line 970 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
   
   wxArrayString paths;
   wxDir::GetAllFiles(VST3Utils::GetFactoryPresetsPath(mEffectClassInfo), &paths);
 
   std::vector<FactoryPresetDesc> result;
   for(auto& path : paths)
   {
      wxFileName filename(path);
      result.push_back({ filename.GetFullPath(), filename.GetName() });
   }
 
   auto cache = GetCache(mEffectClassInfo.ID());
   if(cache->rootUnitProgramChangeParameterID != Vst::kNoParamId &&
      cache->rootUnitProgramCount > 0)
   {
      Vst::String128 programName;
      if(cache->rootUnitProgramListID != Vst::kNoProgramListId)
      {
         auto unitInfoProvider = FUnknownPtr<Vst::IUnitInfo>(mEditController);
         
         for(int32 programIndex = 0, programCount = cache->rootUnitProgramCount;
             programIndex < programCount;
             ++programIndex)
         {
            if(unitInfoProvider->getProgramName(cache->rootUnitProgramListID, programIndex, programName) != kResultOk)
               programName[0] = 0;
            auto presetDisplayName = VST3Utils::ToWxString(programName);
            if(presetDisplayName.empty())
               presetDisplayName = wxString::Format("Unit %03d - %04d", Vst::kRootUnitId, programIndex);
            
            result.push_back({
               VST3Utils::MakeFactoryPresetID(Vst::kRootUnitId, programIndex),
               presetDisplayName
            });
         }
      }
      else
      {
         for(int32_t programIndex = 0; programIndex < cache->rootUnitProgramCount; ++programIndex)
         {
            auto normalizedValue = mEditController->plainParamToNormalized(cache->rootUnitProgramChangeParameterID, programIndex);
            if(mEditController->getParamStringByValue(cache->rootUnitProgramChangeParameterID, normalizedValue, programName) == kResultOk)
            {
               result.push_back({
                  VST3Utils::MakeFactoryPresetID(Vst::kRootUnitId, programIndex),
                  VST3Utils::ToWxString(programName)
               });
            }
         }
      }
   }
 
   return result;
}

References anonymous_namespace{VST3Wrapper.cpp}::GetCache(), VST3Utils::GetFactoryPresetsPath(), VST3Utils::MakeFactoryPresetID(), mEditController, mEffectClassInfo, and VST3Utils::ToWxString().

Referenced by VST3EffectBase::GetFactoryPresets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FlushParameters()

void VST3Wrapper::FlushParameters	(	EffectSettings &	settings,
		bool *	hasChanges = `nullptr`
	)

Parameters

hasChanges optional output variable, set to true if flushing has changed the DSP model state

Definition at line 825 of file VST3Wrapper.cpp.

{
   if(!mActive)
   {
      auto componentHandler = static_cast<ComponentHandler*>(mComponentHandler.get());
      componentHandler->FlushCache(settings);
 
      const auto doProcessing = !GetSettings(settings).parameterChanges.empty();
 
      if(hasChanges != nullptr)
         *hasChanges = doProcessing;
 
      if(!doProcessing)
         return;
 
      SetupProcessing(*mEffectComponent, mSetup);
      mActive = true;
      if(mEffectComponent->setActive(true) == Steinberg::kResultOk)
      {
         ConsumeChanges(settings);
         if(mAudioProcessor->setProcessing(true) != Steinberg::kResultFalse)
         {
            mProcessContext.sampleRate = mSetup.sampleRate;
            mProcessContext.state = 0;
            Process(nullptr, nullptr, 0);
            mAudioProcessor->setProcessing(false);
         }
      }
      mEffectComponent->setActive(false);
      mActive = false;
   }
   else if(hasChanges != nullptr)
      *hasChanges = false;
}

References ConsumeChanges(), anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mActive, mAudioProcessor, mComponentHandler, mEffectComponent, mProcessContext, mSetup, anonymous_namespace{VST3Wrapper.cpp}::VST3EffectSettings::parameterChanges, Process(), settings(), and anonymous_namespace{VST3Wrapper.cpp}::SetupProcessing().

Referenced by VST3EffectBase::LoadFactoryPreset(), VST3Editor::OnClose(), VST3Editor::OnIdle(), and VST3Editor::ValidateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEffectClassInfo()

const VST3::Hosting::ClassInfo & VST3Wrapper::GetEffectClassInfo ( ) const

Definition at line 583 of file VST3Wrapper.cpp.

{
   return mEffectClassInfo;
}

References mEffectClassInfo.

◆ GetLatencySamples()

Steinberg::int32 VST3Wrapper::GetLatencySamples ( ) const

Definition at line 1029 of file VST3Wrapper.cpp.

{
   return mAudioProcessor->getLatencySamples();
}

References mAudioProcessor.

◆ GetModule()

VST3::Hosting::Module & VST3Wrapper::GetModule ( ) const

inline

Definition at line 86 of file VST3Wrapper.h.

86{ return mModule; }

◆ Initialize()

bool VST3Wrapper::Initialize	(	EffectSettings &	settings,
		Steinberg::Vst::SampleRate	sampleRate,
		Steinberg::int32	processMode,
		Steinberg::int32	maxSamplesPerBlock
	)

Initializes effect for processing using settings.

Definition at line 744 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   Vst::ProcessSetup setup = {
      processMode,
      Vst::kSample32,
      maxSamplesPerBlock,
      sampleRate
   };
   
   if(!SetupProcessing(*mEffectComponent.get(), setup))
      return false;
 
   mSetup = setup;
 
   FetchSettings(settings);
 
   if(mEffectComponent->setActive(true) == kResultOk)
   {
      if(mAudioProcessor->setProcessing(true) != kResultFalse)
      {
         mProcessContext.state = Vst::ProcessContext::kPlaying;
         mProcessContext.sampleRate = sampleRate;
 
         mActive = true;
         ConsumeChanges(settings);
         //make zero-flush, to make sure parameters are delivered to the processor...
         Process(nullptr, nullptr, 0);
         StoreSettings(settings);
         return true;
      }
   }
   return false;
}

References ConsumeChanges(), FetchSettings(), mActive, mAudioProcessor, mEffectComponent, mProcessContext, mSetup, Process(), anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, settings(), anonymous_namespace{VST3Wrapper.cpp}::SetupProcessing(), and StoreSettings().

Here is the call graph for this function:

◆ InitializeComponents()

void VST3Wrapper::InitializeComponents ( )

Should be called once before almost any other method call.

Definition at line 545 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   //Preinitialize with some default values in case if parameters
   //flush happens before processing initialized
   mSetup.maxSamplesPerBlock = 512;
   mSetup.processMode = Vst::kOffline;
   mSetup.symbolicSampleSize = Vst::kSample32;
   mSetup.sampleRate = 44100.0;
 
   if(!SetupProcessing(*mEffectComponent, mSetup))
      throw std::runtime_error("bus configuration not supported");
 
   mParameterQueues = std::make_unique<SingleInputParameterValue[]>(mEditController->getParameterCount());
   mParameters.reserve(mEditController->getParameterCount());
 
   Steinberg::MemoryStream stateStream;
   if(mEffectComponent->getState(&stateStream) == kResultOk)
   {
      int64 unused;
      stateStream.seek(0, IBStream::kIBSeekSet, &unused);
      mEditController->setComponentState(&stateStream);
   }
 
   {
      auto cache = GetCache(mEffectClassInfo.ID());
      if(!cache->defaultSettings.has_value())
      {
         cache->defaultSettings = MakeSettings();
         StoreSettings(cache->defaultSettings);
      }
   }
 
   static_cast<ComponentHandler*>(mComponentHandler.get())
      ->LoadCurrentParamValues();
}

References anonymous_namespace{VST3Wrapper.cpp}::GetCache(), MakeSettings(), mComponentHandler, mEditController, mEffectClassInfo, mEffectComponent, mParameterQueues, mParameters, mSetup, Steinberg::MemoryStream::seek(), anonymous_namespace{VST3Wrapper.cpp}::SetupProcessing(), and StoreSettings().

Referenced by VST3EffectBase::LoadFactoryPreset(), and VST3PluginValidator::Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsActive()

bool VST3Wrapper::IsActive ( ) const

noexcept

Definition at line 588 of file VST3Wrapper.cpp.

{
   return mActive;
}

References mActive.

Referenced by VST3Editor::OnIdle(), and anonymous_namespace{VST3Wrapper.cpp}::ComponentHandler::performEdit().

Here is the caller graph for this function:

◆ LoadPreset()

void VST3Wrapper::LoadPreset ( const wxString & presetId )

Definition at line 652 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   auto cache = GetCache(mEffectClassInfo.ID());
 
   if(cache->rootUnitProgramChangeParameterID != Vst::kNoParamId &&
      cache->rootUnitProgramCount > 0)
   {
      Vst::UnitID unitId;
      int32 programIndex; 
      if(VST3Utils::ParseFactoryPresetID(presetId, unitId, programIndex) &&
         programIndex >= 0 && programIndex < cache->rootUnitProgramCount)
      {
         auto paramValueNormalized = static_cast<Vst::ParamValue>(programIndex);
         if(cache->rootUnitProgramCount > 1)
            paramValueNormalized /= static_cast<Vst::ParamValue>(cache->rootUnitProgramCount - 1);
 
         mEditController->setParamNormalized(
            cache->rootUnitProgramChangeParameterID,
            paramValueNormalized);
 
         if(mComponentHandler)
         {
            mComponentHandler->beginEdit(cache->rootUnitProgramChangeParameterID);
            auto commit = finally([&] { mComponentHandler->endEdit(cache->rootUnitProgramChangeParameterID); });
            mComponentHandler->performEdit(
               cache->rootUnitProgramChangeParameterID,
               paramValueNormalized);
         }
 
         return;
      }
   }
 
   auto fileStream = owned(Vst::FileStream::open(presetId.c_str(), "rb"));
   if(!fileStream)
      throw FileException(FileException::Cause::Open, presetId);
 
   if(!LoadPresetFromStream(fileStream))
   {
      throw SimpleMessageBoxException(
         ExceptionType::BadEnvironment,
         XO("Unable to apply VST3 preset file %s").Format(presetId),
         XO("Error"));
   }
}

References BadEnvironment, anonymous_namespace{VST3Wrapper.cpp}::GetCache(), LoadPresetFromStream(), mComponentHandler, mEditController, mEffectClassInfo, FileException::Open, VST3Utils::ParseFactoryPresetID(), and XO().

Referenced by VST3EffectBase::LoadFactoryPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadPresetFromStream()

bool VST3Wrapper::LoadPresetFromStream ( Steinberg::IBStream * fileStream )

private

Definition at line 716 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   return Vst::PresetFile::loadPreset
   (
      fileStream,
      FUID::fromTUID(mEffectClassInfo.ID().data()),
      mEffectComponent.get(),
      mEditController.get()
   );
}

References mEditController, mEffectClassInfo, and mEffectComponent.

Referenced by LoadPreset().

Here is the caller graph for this function:

◆ LoadSettings()

void VST3Wrapper::LoadSettings	(	const CommandParameters &	parms,
		EffectSettings &	settings
	)

static

Definition at line 1039 of file VST3Wrapper.cpp.

{
   VST3EffectSettings vst3settings;
 
   if(parms.HasEntry(processorStateKey))
   {
      vst3settings.processorState = parms.Read(processorStateKey);
      if(parms.HasEntry(controllerStateKey))
         vst3settings.controllerState = parms.Read(controllerStateKey);
   }
   if(parms.HasEntry(parametersKey))
      vst3settings.parameterChanges = ParametersFromString(parms.Read(parametersKey));
 
   std::swap(vst3settings, GetSettings(settings));
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), CommandParameters::HasEntry(), anonymous_namespace{VST3Wrapper.cpp}::ParametersFromString(), anonymous_namespace{VST3Wrapper.cpp}::parametersKey, anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, settings(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by VST3EffectBase::LoadSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadUserPreset()

OptionalMessage VST3Wrapper::LoadUserPreset	(	const EffectDefinitionInterface &	effect,
		const RegistryPath &	name,
		EffectSettings &	settings
	)

static

Definition at line 1067 of file VST3Wrapper.cpp.

{
   VST3EffectSettings vst3settings;
   
   wxString processorStateStr;
   if(GetConfig(effect, PluginSettings::Private, name, processorStateKey, processorStateStr, wxEmptyString))
   {
      vst3settings.processorState = processorStateStr;
      wxString controllerStateStr;
      if(GetConfig(effect, PluginSettings::Private, name, controllerStateKey, controllerStateStr, wxEmptyString))
         vst3settings.controllerState = controllerStateStr;
   }
   wxString parametersStr;
   if(GetConfig(effect, PluginSettings::Private, name, parametersKey, parametersStr, wxEmptyString))
      vst3settings.parameterChanges = ParametersFromString(parametersStr);
 
   std::swap(vst3settings, GetSettings(settings));
   return { nullptr };
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, PluginSettings::GetConfig(), anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), name, anonymous_namespace{VST3Wrapper.cpp}::ParametersFromString(), anonymous_namespace{VST3Wrapper.cpp}::parametersKey, PluginSettings::Private, anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, settings(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by VST3EffectBase::LoadUserPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeSettings()

EffectSettings VST3Wrapper::MakeSettings ( )

static

Definition at line 1034 of file VST3Wrapper.cpp.

{
   return EffectSettings::Make<VST3EffectSettings>();
}

Referenced by InitializeComponents(), and VST3EffectBase::MakeSettings().

Here is the caller graph for this function:

◆ operator=() [1/2]

VST3Wrapper & VST3Wrapper::operator= ( const VST3Wrapper & )

delete

◆ operator=() [2/2]

VST3Wrapper & VST3Wrapper::operator= ( VST3Wrapper && )

delete

◆ Process()

size_t VST3Wrapper::Process	(	const float const	inBlock,
		float const	outBlock,
		size_t	blockLen
	)

Definition at line 860 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
   
   InputParameterChanges inputParameterChanges(mParameters, mParameterQueues.get());
   mParameters.clear();
 
   Vst::ProcessData data;
   data.processMode = mSetup.processMode;
   data.symbolicSampleSize = mSetup.symbolicSampleSize;
   data.inputParameterChanges = &inputParameterChanges;
   data.processContext = &mProcessContext;
 
   static_assert(std::numeric_limits<decltype(blockLen)>::max()
      >= std::numeric_limits<decltype(data.numSamples)>::max());
 
   data.numSamples = static_cast<decltype(data.numSamples)>(std::min(
      blockLen, 
      static_cast<decltype(blockLen)>(mSetup.maxSamplesPerBlock)
   ));
 
   data.numInputs = inBlock == nullptr ? 0 : mEffectComponent->getBusCount(Vst::kAudio, Vst::kInput);
   data.numOutputs = outBlock == nullptr ? 0 : mEffectComponent->getBusCount(Vst::kAudio, Vst::kOutput);
 
   if(data.numInputs > 0)
   {
      int inputBlocksOffset {0};
 
      data.inputs = static_cast<Vst::AudioBusBuffers*>(
         alloca(sizeof(Vst::AudioBusBuffers) * data.numInputs));
 
      for(int busIndex = 0; busIndex < data.numInputs; ++busIndex)
      {
         Vst::BusInfo busInfo { };
         if(mEffectComponent->getBusInfo(Vst::kAudio, Vst::kInput, busIndex, busInfo) != kResultOk)
         {
            return 0;
         }
         if(busInfo.busType == Vst::kMain)
         {
            data.inputs[busIndex].numChannels = busInfo.channelCount;
            data.inputs[busIndex].channelBuffers32 = const_cast<float**>(inBlock + inputBlocksOffset);
            inputBlocksOffset += busInfo.channelCount;
         }
         else
         {
            //aux is not yet supported
            data.inputs[busIndex].numChannels = 0;
            data.inputs[busIndex].channelBuffers32 = nullptr;
         }
         data.inputs[busIndex].silenceFlags = 0UL;
      }
   }
   if(data.numOutputs > 0)
   {
      int outputBlocksOffset {0};
 
      data.outputs = static_cast<Vst::AudioBusBuffers*>(
         alloca(sizeof(Vst::AudioBusBuffers) * data.numOutputs));
      for(int busIndex = 0; busIndex < data.numOutputs; ++busIndex)
      {
         Vst::BusInfo busInfo { };
         if(mEffectComponent->getBusInfo(Vst::kAudio, Vst::kOutput, busIndex, busInfo) != kResultOk)
         {
            return 0;
         }
         if(busInfo.busType == Vst::kMain)
         {
            data.outputs[busIndex].numChannels = busInfo.channelCount;
            data.outputs[busIndex].channelBuffers32 = const_cast<float**>(outBlock + outputBlocksOffset);
            outputBlocksOffset += busInfo.channelCount;
         }
         else
         {
            //aux is not yet supported
            data.outputs[busIndex].numChannels = 0;
            data.outputs[busIndex].channelBuffers32 = nullptr;
         }
         data.outputs[busIndex].silenceFlags = 0UL;
      }
   }
 
   const auto processResult = mAudioProcessor->process(data);
   
   return processResult == kResultOk ?
      data.numSamples : 0;
}

References mAudioProcessor, mEffectComponent, min(), mParameterQueues, mParameters, mProcessContext, and mSetup.

Referenced by Finalize(), FlushParameters(), and Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessBlockStart()

void VST3Wrapper::ProcessBlockStart ( const EffectSettings & settings )

Prepares effect to process next block with changes written to the settings object.

Definition at line 798 of file VST3Wrapper.cpp.

{
   ConsumeChanges(settings);
}

References ConsumeChanges(), and settings().

Here is the call graph for this function:

◆ ResumeProcessing()

void VST3Wrapper::ResumeProcessing ( )

Definition at line 954 of file VST3Wrapper.cpp.

{
   mAudioProcessor->setProcessing(true);
}

References mAudioProcessor.

◆ SavePresetToFile()

void VST3Wrapper::SavePresetToFile ( const wxString & filepath ) const

Definition at line 700 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   auto fileStream = owned(Vst::FileStream::open(filepath.c_str(), "wb"));
   if(!fileStream)
      throw FileException(FileException::Cause::Open, filepath);
 
   if(!SavePresetToStream(fileStream))
      throw SimpleMessageBoxException(
         ExceptionType::BadEnvironment,
         XO("Failed to save VST3 preset to file"),
         XO("Error"));
}

References BadEnvironment, FileException::Open, SavePresetToStream(), and XO().

Here is the call graph for this function:

◆ SavePresetToStream()

bool VST3Wrapper::SavePresetToStream ( Steinberg::IBStream * fileStream ) const

private

Definition at line 730 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   return Vst::PresetFile::savePreset
   (
      fileStream,
      FUID::fromTUID(mEffectClassInfo.ID().data()),
      mEffectComponent.get(),
 
      mEditController.get()
   );
}

References mEditController, mEffectClassInfo, and mEffectComponent.

Referenced by SavePresetToFile().

Here is the caller graph for this function:

◆ SaveSettings()

void VST3Wrapper::SaveSettings	(	const EffectSettings &	settings,
		CommandParameters &	parms
	)

static

Definition at line 1055 of file VST3Wrapper.cpp.

{
   const auto& vst3settings = GetSettings(settings);
 
   if(vst3settings.processorState.has_value())
      parms.Write(processorStateKey, *vst3settings.processorState);
   if(vst3settings.controllerState.has_value())
      parms.Write(controllerStateKey, *vst3settings.controllerState);
   if(!vst3settings.parameterChanges.empty())
      parms.Write(parametersKey, ParametersToString(vst3settings.parameterChanges)); 
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), anonymous_namespace{VST3Wrapper.cpp}::parametersKey, anonymous_namespace{VST3Wrapper.cpp}::ParametersToString(), anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, and settings().

Referenced by VST3EffectBase::SaveSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveUserPreset()

void VST3Wrapper::SaveUserPreset	(	const EffectDefinitionInterface &	effect,
		const RegistryPath &	name,
		const EffectSettings &	settings
	)

static

Definition at line 1088 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   const auto& vst3settings = GetSettings(settings);
   if(vst3settings.processorState.has_value())
   {
      SetConfig(effect, PluginSettings::Private, name, processorStateKey, *vst3settings.processorState);
      if(vst3settings.controllerState.has_value())
         SetConfig(effect, PluginSettings::Private, name, controllerStateKey, *vst3settings.controllerState);
   }
   if(!vst3settings.parameterChanges.empty())
      SetConfig(effect, PluginSettings::Private, name, parametersKey, ParametersToString(vst3settings.parameterChanges));
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), name, anonymous_namespace{VST3Wrapper.cpp}::parametersKey, anonymous_namespace{VST3Wrapper.cpp}::ParametersToString(), PluginSettings::Private, anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, PluginSettings::SetConfig(), and settings().

Referenced by VST3EffectBase::SaveUserPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StoreSettings()

void VST3Wrapper::StoreSettings ( EffectSettings & settings ) const

Saves current state inside settings object, clears all runtime data.

Definition at line 632 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
   
   VST3EffectSettings vst3settings;
 
   {
      PresetsBufferStream processorState;
      if(mEffectComponent->getState(&processorState) == kResultOk)
         vst3settings.processorState = processorState.toString();
   }
   {
      PresetsBufferStream controllerState;
      if(mEditController->getState(&controllerState) == kResultOk)
         vst3settings.controllerState = controllerState.toString();
   }
   
   std::swap(vst3settings, GetSettings(settings));
}

References anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mEditController, mEffectComponent, settings(), anonymous_namespace{NoteTrack.cpp}::swap(), and PresetsBufferStream::toString().

Referenced by Finalize(), Initialize(), InitializeComponents(), VST3EffectBase::LoadFactoryPreset(), VST3Editor::OnClose(), VST3Editor::OnIdle(), and VST3Editor::ValidateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SuspendProcessing()

void VST3Wrapper::SuspendProcessing ( )

Definition at line 949 of file VST3Wrapper.cpp.

{
   mAudioProcessor->setProcessing(false);
}

References mAudioProcessor.

Member Data Documentation

◆ mActive

bool VST3Wrapper::mActive {false}

private

Definition at line 153 of file VST3Wrapper.h.

Referenced by Finalize(), FlushParameters(), Initialize(), and IsActive().

◆ mAudioProcessor

Steinberg::IPtr<Steinberg::Vst::IAudioProcessor> VST3Wrapper::mAudioProcessor

Definition at line 67 of file VST3Wrapper.h.

Referenced by Finalize(), FlushParameters(), GetLatencySamples(), Initialize(), Process(), ResumeProcessing(), SuspendProcessing(), and VST3Wrapper().

◆ mComponentConnectionProxy

Steinberg::IPtr<Steinberg::Vst::IConnectionPoint> VST3Wrapper::mComponentConnectionProxy

Definition at line 71 of file VST3Wrapper.h.

Referenced by VST3Wrapper(), and ~VST3Wrapper().

◆ mComponentHandler

Steinberg::IPtr<Steinberg::Vst::IComponentHandler> VST3Wrapper::mComponentHandler

Definition at line 73 of file VST3Wrapper.h.

Referenced by BeginParameterEdit(), EndParameterEdit(), FetchSettings(), FlushParameters(), InitializeComponents(), LoadPreset(), VST3Editor::VST3Editor(), and VST3Wrapper().

◆ mControllerConnectionProxy

Steinberg::IPtr<Steinberg::Vst::IConnectionPoint> VST3Wrapper::mControllerConnectionProxy

Definition at line 72 of file VST3Wrapper.h.

Referenced by VST3Wrapper(), and ~VST3Wrapper().

◆ mDefaultSettings

EffectSettings VST3Wrapper::mDefaultSettings

private

Definition at line 56 of file VST3Wrapper.h.

◆ mEditController

Steinberg::IPtr<Steinberg::Vst::IEditController> VST3Wrapper::mEditController

Definition at line 70 of file VST3Wrapper.h.

Referenced by FetchSettings(), FindFactoryPresets(), InitializeComponents(), anonymous_namespace{VST3Wrapper.cpp}::ComponentHandler::LoadCurrentParamValues(), LoadPreset(), LoadPresetFromStream(), SavePresetToStream(), StoreSettings(), VST3Editor::TryLoadNativeUI(), VST3Editor::VST3Editor(), VST3Wrapper(), and ~VST3Wrapper().

◆ mEffectClassInfo

const VST3::Hosting::ClassInfo& VST3Wrapper::mEffectClassInfo

private

Definition at line 58 of file VST3Wrapper.h.

Referenced by FetchSettings(), FindFactoryPresets(), GetEffectClassInfo(), InitializeComponents(), LoadPreset(), LoadPresetFromStream(), SavePresetToStream(), and VST3Wrapper().

◆ mEffectComponent

Steinberg::IPtr<Steinberg::Vst::IComponent> VST3Wrapper::mEffectComponent

Definition at line 69 of file VST3Wrapper.h.

Referenced by FetchSettings(), Finalize(), FlushParameters(), Initialize(), InitializeComponents(), LoadPresetFromStream(), Process(), SavePresetToStream(), StoreSettings(), VST3Wrapper(), and ~VST3Wrapper().

◆ mModule

VST3::Hosting::Module& VST3Wrapper::mModule

private

Definition at line 57 of file VST3Wrapper.h.

◆ mParameterQueues

std::unique_ptr<SingleInputParameterValue[]> VST3Wrapper::mParameterQueues

private

Definition at line 160 of file VST3Wrapper.h.

Referenced by InitializeComponents(), and Process().

◆ mParameters

std::vector<std::pair<Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue> > VST3Wrapper::mParameters

private

Definition at line 155 of file VST3Wrapper.h.

Referenced by ConsumeChanges(), InitializeComponents(), and Process().

◆ mProcessContext

Steinberg::Vst::ProcessContext VST3Wrapper::mProcessContext { }

private

Definition at line 162 of file VST3Wrapper.h.

Referenced by Finalize(), FlushParameters(), Initialize(), and Process().

◆ mSetup

Steinberg::Vst::ProcessSetup VST3Wrapper::mSetup

Definition at line 68 of file VST3Wrapper.h.

Referenced by FlushParameters(), Initialize(), InitializeComponents(), Process(), and VST3Editor::VST3Editor().

◆ ParamChangedHandler

std::function<void (Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue)> VST3Wrapper::ParamChangedHandler

Definition at line 143 of file VST3Wrapper.h.

Referenced by anonymous_namespace{VST3Wrapper.cpp}::ComponentHandler::NotifyParamChange(), VST3Editor::OnClose(), VST3Editor::VST3Editor(), and VST3Editor::~VST3Editor().

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ VST3Wrapper() [1/3]

◆ ~VST3Wrapper()

◆ VST3Wrapper() [2/3]

◆ VST3Wrapper() [3/3]

Member Function Documentation

◆ BeginParameterEdit()

◆ ConsumeChanges()

◆ CopySettingsContents()

◆ EndParameterEdit()

◆ FetchSettings()

◆ Finalize()

◆ FindFactoryPresets()

◆ FlushParameters()

◆ GetEffectClassInfo()

◆ GetLatencySamples()

◆ GetModule()

◆ Initialize()

◆ InitializeComponents()

◆ IsActive()

◆ LoadPreset()

◆ LoadPresetFromStream()

◆ LoadSettings()

◆ LoadUserPreset()

◆ MakeSettings()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ Process()

◆ ProcessBlockStart()

◆ ResumeProcessing()

◆ SavePresetToFile()

◆ SavePresetToStream()

◆ SaveSettings()

◆ SaveUserPreset()

◆ StoreSettings()

◆ SuspendProcessing()

Member Data Documentation

◆ mActive

◆ mAudioProcessor

◆ mComponentConnectionProxy

◆ mComponentHandler

◆ mControllerConnectionProxy

◆ mDefaultSettings

◆ mEditController

◆ mEffectClassInfo

◆ mEffectComponent

◆ mModule

◆ mParameterQueues

◆ mParameters

◆ mProcessContext

◆ mSetup

◆ ParamChangedHandler